(******************************************************************************)
(*                                                                            *)
(*                     Generalised Hanoi Problem                              *)
(*                                                                            *)
(******************************************************************************)
(*                                                                            *)
(*      We consider a generalisation of Hanoi problem :                       *)
(*        a parameter n : the number of pegs                                  *)
(*        a parameter r : r p1 p2 tells that a disk can go from p1 -> p2      *)
(*                                                                            *)
(*    peg n             == type for pegs  (there are n pegs)                  *)
(*    disk k            == type for disks (there are k disk)                  *)
(*    configuration k n == type for hanoi configuration with                  *)
(*                         k disks and n pegs                                 *)
(*    ldisk             == the largest disk                                   *)
(*    sdisk             == the smallest disk                                  *)
(*    d1 \larger d2     == disk d1 is larger than disk d2                     *)
(*    c d               == the peg on which the disk d in the configuration c *)
(*    `c[p]             == a configuration with n disk where all the disks    *)
(*    `p[p1, p2]        == pick a peg (if possible) that is diffenent from p1 *)
(*                         and p2                                             *)
(*                         are on peg p                                       *)
(*    on_top d c        == the disk c is on top of its peg on the             *)
(*                         configuration c                                    *)
(*    rrel              == a regular relation between pegs, rrel p1 p2 is     *)
(*                         true iff peg p1 is different from peg p2           *)
(*    lrel              == a linear relation between pegs, lrel p1 p2 is      *)
(*                         true iff peg p1 is next to peg p2                  *)
(*    srel              == a star relation between pegs, srel p1 p2 is        *)
(*                         true iff p1 != p2 and p1 or p2 is the 0 peg        *)
(*    move r c1 c2      == checks if going from configuration c1              *)
(*                         to configuration c2 is a move compatible with      *)
(*                         relation r (a relation over pegs)                  *)
(*   cdisjoint c1 c2    == configurations c1 and c2 are on different pegs     *) 
(*   cmerge c1 c2       == merge a configuration c1 with m disk and a         *)
(*                         a configuration with n disks to get a configuration*) 
(*                         with m + n disk                                    *)
(*   crshift c          == right shift a configuration c with m + n disks, to *)
(*                         get a configuration with n disks taking the disks  *)
(*                         larger than m                                      *)
(*   clshift c          == right shift a configuration c with m + n disks, to *)
(*                         get a configuration with n disks taking the disks  *)
(*                         smaller than m                                     *)
(*   ↑[c]_ p            == lift a configuration by adding a largest disk on   *)
(*                         peg p. This lifting is done from the largest one   *)
(*                         so to accomodate the usual induction               *)
(*   ↓[c]               == unlift a configuration by removing the largest     *)
(*                         disk                                               *)
(*   plift i p          == lift a configuration by adding a new empty peg i   *)
(*                                                                            *)
(******************************************************************************)

From mathcomp Require Import all_ssreflect finmap.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "_ + _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ - _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ <= _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ < _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ >= _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ > _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ <= _ <= _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ < _ <= _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ <= _ < _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ < _ < _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ * _" was already used in scope nat_scope.
[notation-overridden,parsing]
From hanoi Require Import extra gdist.

Set Implicit Arguments.
Unset Strict Implicit.
Unset Printing Implicit Defensive.

Section GHanoi.

Variable q : nat.

(******************************************************************************)
(*  The pegs are the elements of 'I_q                                         *)
(******************************************************************************)

Definition peg := 'I_q.
Variable r : rel peg.
Hypothesis irH : irreflexive r.
Hypothesis symH : symmetric r.


Section Disk.
(******************************************************************************)
(* The disks are represented with the element of 'I_n with                    *)
(* the idea that disk d1 is larger than disk d2 is d2 <= d1.                  *)
(******************************************************************************)

Variable n : nat.
Definition disk := 'I_n.
Definition mk_disk m (H : m < n) : disk := Ordinal H.

(******************************************************************************)
(* Given a configuration c, the disks on the peg p can be reconstructed by    *)
(* the list in decreasing order of the disk d such that c d = p               *)
(******************************************************************************)

Definition configuration := {ffun disk -> peg}.

(* A perfect configuration is one where all the pegs are on a single peg p *)
Definition perfect p : configuration :=  [ffun d => p].

End Disk.

Arguments perfect [n].

Local Notation "`c[ p ] " := (perfect p)
    (format "`c[ p ]", at level 5).

(* The smallest disk *)
Definition sdisk {n} : disk n.+1 := ord0.

Lemma disk1_all (d : disk 1) : d = sdisk.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
d:disk 1
d = sdisk
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
d:disk 1
d = sdisk by apply/val_eqP; case: d => [] []. Qed.

Lemma configuration1_eq (c1 c2 : configuration 1) : 
  (c1 == c2) = (c1 sdisk == c2 sdisk).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
c1, c2:configuration 1
(c1 == c2) = (c1 sdisk == c2 sdisk)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
c1, c2:configuration 1
(c1 == c2) = (c1 sdisk == c2 sdisk)
apply/eqP/eqP; first by move=> /ffunP/(_ sdisk).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
c1, c2:configuration 1
c1 sdisk = c2 sdisk -> c1 = c2
by move=> H; apply/ffunP=> i; rewrite [i]disk1_all.
Qed.

(* The largest disk *)
Definition ldisk {n} : disk n.+1 := ord_max.

(******************************************************************************)
(* The disk d is on top of peg (c d)                                          *)
(******************************************************************************)

Definition on_top n (d : disk n) (c : configuration n) :=
   [forall d1 : disk n, (c d == c d1) ==> (d <= d1)].

Lemma on_topP n (d : disk n) (c : configuration n) :
  reflect (forall d1, c d = c d1 -> d <= d1) (on_top d c).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c:configuration n
reflect
  (forall d1 : ordinal_finType n,
   c d = c d1 -> d <= d1) (on_top d c)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c:configuration n
reflect
  (forall d1 : ordinal_finType n,
   c d = c d1 -> d <= d1) (on_top d c)
apply: (iffP forallP) => [H d1 cdEcd1|H d1].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c:configuration n
H:forall x : ordinal_finType n,
(c d == c x) ==> (d <= x)
d1:ordinal_finType n
cdEcd1:c d = c d1
d <= d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c:configuration n
H:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:ordinal_finType n
(c d == c d1) ==> (d <= d1)
  by have /implyP->// := H d1; apply/eqP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c:configuration n
H:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:ordinal_finType n
(c d == c d1) ==> (d <= d1)
by apply/implyP=> /eqP /H.
Qed.

(******************************************************************************)
(* A move is a relation between two configurations c1 c2:                     *)
(* there must exist a disk d1, that is the only one that has changed of       *)
(* peg (c1 d1 != c2 d1) that is on top of c1 and c2                           *)
(******************************************************************************)


Definition move {n} : rel (configuration n) :=
   [rel c1 c2 | [exists d1 : disk n, 
                  [&& r ((c1 : configuration n) d1) (c2 d1),
                      [forall d2, (d1 != d2) ==> (c1 d2 == c2 d2)],
                      on_top d1 c1 & 
                      on_top d1 c2]]].

Lemma moveP n (c1 c2 : configuration n) :
  reflect 
    (exists d1, 
         [/\ r (c1 d1) (c2 d1),
             forall d2, d1 != d2 -> c1 d2 = c2 d2,
             on_top d1 c1 &
             on_top d1 c2])
    (move c1 c2).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n
reflect
  (exists d1 : ordinal_finType n,
     [/\ r (c1 d1) (c2 d1),
         forall d2 : ordinal_finType n,
         d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1
       & on_top d1 c2]) (move c1 c2)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n
reflect
  (exists d1 : ordinal_finType n,
     [/\ r (c1 d1) (c2 d1),
         forall d2 : ordinal_finType n,
         d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1
       & on_top d1 c2]) (move c1 c2)
apply: (iffP existsP) =>
  [[d /and4P[H1 /forallP H2 H3 H4]]|[d [H1 H2 H3 H4]]]; exists d.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n
d:ordinal_finType n
H1:r (c1 d) (c2 d)
H2:forall x : ordinal_finType n,
(d != x) ==> (c1 x == c2 x)
H3:on_top d c1
H4:on_top d c2
[/\ r (c1 d) (c2 d),
    forall d2 : ordinal_finType n,
    d != d2 -> c1 d2 = c2 d2, on_top d c1
  & on_top d c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n
d:ordinal_finType n
H1:r (c1 d) (c2 d)
H2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
H3:on_top d c1
H4:on_top d c2
[&& r (c1 d) (c2 d),
    [forall d2, (d != d2) ==> (c1 d2 == c2 d2)],
    on_top d c1
  & on_top d c2]
  by split => // d1 H; apply/eqP/(implyP (H2 _)).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n
d:ordinal_finType n
H1:r (c1 d) (c2 d)
H2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
H3:on_top d c1
H4:on_top d c2
[&& r (c1 d) (c2 d),
    [forall d2, (d != d2) ==> (c1 d2 == c2 d2)],
    on_top d c1
  & on_top d c2]
rewrite H1 H3 H4 ! andbT /=; apply/forallP => d1; apply/implyP => H.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n
d:ordinal_finType n
H1:r (c1 d) (c2 d)
H2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
H3:on_top d c1
H4:on_top d c2
d1:ordinal_finType n
H:d != d1
c1 d1 == c2 d1
by rewrite H2.
Qed.

Lemma move_on_topl n d (c1 c2 : configuration n) : 
  move c1 c2 -> c1 d != c2 d -> on_top d c1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
move c1 c2 -> c1 d != c2 d -> on_top d c1
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
move c1 c2 -> c1 d != c2 d -> on_top d c1
case/moveP => d1 [H1 H2 H3 H4 H5].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
d1:ordinal_finType n
H1:r (c1 d1) (c2 d1)
H2:forall d2 : ordinal_finType n,
d1 != d2 -> c1 d2 = c2 d2
H3:on_top d1 c1
H4:on_top d1 c2
H5:c1 d != c2 d
on_top d c1
rewrite (_ : d = d1); first by apply: H3.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
d1:ordinal_finType n
H1:r (c1 d1) (c2 d1)
H2:forall d2 : ordinal_finType n,
d1 != d2 -> c1 d2 = c2 d2
H3:on_top d1 c1
H4:on_top d1 c2
H5:c1 d != c2 d
d = d1
apply/eqP; case: eqP => /eqP H //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
d1:ordinal_finType n
H1:r (c1 d1) (c2 d1)
H2:forall d2 : ordinal_finType n,
d1 != d2 -> c1 d2 = c2 d2
H3:on_top d1 c1
H4:on_top d1 c2
H5:c1 d != c2 d
H:d != d1
false
by case/eqP: H5; apply: H2; rewrite eq_sym.
Qed.

Lemma move_on_topr n d (c1 c2 : configuration n) : 
  move c1 c2 -> c1 d != c2 d -> on_top d c2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
move c1 c2 -> c1 d != c2 d -> on_top d c2
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
move c1 c2 -> c1 d != c2 d -> on_top d c2
case/moveP => d1 [H1 H2 H3 H4 H5].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
d1:ordinal_finType n
H1:r (c1 d1) (c2 d1)
H2:forall d2 : ordinal_finType n,
d1 != d2 -> c1 d2 = c2 d2
H3:on_top d1 c1
H4:on_top d1 c2
H5:c1 d != c2 d
on_top d c2
rewrite (_ : d = d1); first by apply: H4.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
d1:ordinal_finType n
H1:r (c1 d1) (c2 d1)
H2:forall d2 : ordinal_finType n,
d1 != d2 -> c1 d2 = c2 d2
H3:on_top d1 c1
H4:on_top d1 c2
H5:c1 d != c2 d
d = d1
apply/eqP; case: eqP => /eqP H //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
d1:ordinal_finType n
H1:r (c1 d1) (c2 d1)
H2:forall d2 : ordinal_finType n,
d1 != d2 -> c1 d2 = c2 d2
H3:on_top d1 c1
H4:on_top d1 c2
H5:c1 d != c2 d
H:d != d1
false
by case/eqP: H5; apply: H2; rewrite eq_sym.
Qed.

(* this holds if r is symmetric *)
Lemma move_sym n (c1 c2 : configuration n) : move c1 c2 = move c2 c1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n
move c1 c2 = move c2 c1
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n
move c1 c2 = move c2 c1
by apply/moveP/moveP=> [] [d [H1 H2 H3 H4]];
   exists d; split; rewrite 1?symH 1?eq_sym // => e dDe; apply/sym_equal/H2.
Qed.

(* In a move, the disk that moves accomodates r                               *)
Lemma move_diskr n (d : disk n) (c1 c2 : configuration n) : 
  move c1 c2 -> c1 d != c2 d -> r (c1 d) (c2 d).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c1, c2:configuration n
move c1 c2 -> c1 d != c2 d -> r (c1 d) (c2 d)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c1, c2:configuration n
move c1 c2 -> c1 d != c2 d -> r (c1 d) (c2 d)
case/moveP=> d1 [H1 H2 H3 H4] /eqP c1dDc2d.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c1, c2:configuration n
d1:ordinal_finType n
H1:r (c1 d1) (c2 d1)
H2:forall d2 : ordinal_finType n,
d1 != d2 -> c1 d2 = c2 d2
H3:on_top d1 c1
H4:on_top d1 c2
c1dDc2d:c1 d <> c2 d
r (c1 d) (c2 d)
by have [/eqP<-|/H2] := boolP (d1 == d).
Qed.

(* In a move, only one disk moves                                             *)
Lemma move_disk1 n (d1 d2 : disk n) (c1 c2 : configuration n) : 
  move c1 c2 -> c1 d1 != c2 d1 -> d1 != d2 -> c1 d2 = c2 d2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d1, d2:disk n
c1, c2:configuration n
move c1 c2 ->
c1 d1 != c2 d1 -> d1 != d2 -> c1 d2 = c2 d2
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d1, d2:disk n
c1, c2:configuration n
move c1 c2 ->
c1 d1 != c2 d1 -> d1 != d2 -> c1 d2 = c2 d2
case/moveP=> d3 [H1 H2 H3 H4] c1d1Dc2d1 d1Dd2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d1, d2:disk n
c1, c2:configuration n
d3:ordinal_finType n
H1:r (c1 d3) (c2 d3)
H2:forall d2 : ordinal_finType n,
d3 != d2 -> c1 d2 = c2 d2
H3:on_top d3 c1
H4:on_top d3 c2
c1d1Dc2d1:c1 d1 != c2 d1
d1Dd2:d1 != d2
c1 d2 = c2 d2
have [/eqP d3Ed1|d3Dd1] := boolP (d3 == d1); last first.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d1, d2:disk n
c1, c2:configuration n
d3:ordinal_finType n
H1:r (c1 d3) (c2 d3)
H2:forall d2 : ordinal_finType n,
d3 != d2 -> c1 d2 = c2 d2
H3:on_top d3 c1
H4:on_top d3 c2
c1d1Dc2d1:c1 d1 != c2 d1
d1Dd2:d1 != d2
d3Dd1:d3 != d1
c1 d2 = c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d1, d2:disk n
c1, c2:configuration n
d3:ordinal_finType n
H1:r (c1 d3) (c2 d3)
H2:forall d2 : ordinal_finType n,
d3 != d2 -> c1 d2 = c2 d2
H3:on_top d3 c1
H4:on_top d3 c2
c1d1Dc2d1:c1 d1 != c2 d1
d1Dd2:d1 != d2
d3Ed1:d3 = d1
c1 d2 = c2 d2
  by case/eqP: c1d1Dc2d1; apply: H2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d1, d2:disk n
c1, c2:configuration n
d3:ordinal_finType n
H1:r (c1 d3) (c2 d3)
H2:forall d2 : ordinal_finType n,
d3 != d2 -> c1 d2 = c2 d2
H3:on_top d3 c1
H4:on_top d3 c2
c1d1Dc2d1:c1 d1 != c2 d1
d1Dd2:d1 != d2
d3Ed1:d3 = d1
c1 d2 = c2 d2
by apply: H2; rewrite d3Ed1.
Qed.

Lemma move_on_toplDl n (d d1 : disk n) (c1 c2 : configuration n) : 
  move c1 c2 -> c1 d != c2 d -> d1 < d -> c1 d1 != c1 d.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
move c1 c2 -> c1 d != c2 d -> d1 < d -> c1 d1 != c1 d
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
move c1 c2 -> c1 d != c2 d -> d1 < d -> c1 d1 != c1 d
move=> c1Mc2 c1Dc2; rewrite  eq_sym ltnNge; apply: contra => /eqP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
c1 d = c1 d1 -> d <= d1
by have /on_topP := move_on_topl c1Mc2 c1Dc2; apply.
Qed.

Lemma move_on_toplDr n (d d1 : disk n) (c1 c2 : configuration n) : 
  move c1 c2 -> c1 d != c2 d -> d1 <= d -> c1 d1 != c2 d.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
move c1 c2 -> c1 d != c2 d -> d1 <= d -> c1 d1 != c2 d
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
move c1 c2 -> c1 d != c2 d -> d1 <= d -> c1 d1 != c2 d
move=> c1Mc2 c1Dc2; rewrite leq_eqVlt => /orP[/val_eqP->//|dLd1].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d
c1 d1 != c2 d
move: (dLd1); rewrite eq_sym ltnNge (move_disk1 c1Mc2 c1Dc2) //; last first.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d
d != d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d
~~ (d <= d1) -> c2 d != c2 d1
  by rewrite neq_ltn dLd1 orbT.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d
~~ (d <= d1) -> c2 d != c2 d1
apply: contra => /eqP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d
c2 d = c2 d1 -> d <= d1
by have /on_topP := move_on_topr c1Mc2 c1Dc2; apply.
Qed.

Lemma move_on_toprDr n (d d1 : disk n) (c1 c2 : configuration n) : 
  move c1 c2 -> c1 d != c2 d -> d1 < d -> c2 d1 != c2 d.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
move c1 c2 -> c1 d != c2 d -> d1 < d -> c2 d1 != c2 d
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
move c1 c2 -> c1 d != c2 d -> d1 < d -> c2 d1 != c2 d
move=> c1Mc2 c1Dc2; rewrite  eq_sym ltnNge; apply: contra => /eqP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
c2 d = c2 d1 -> d <= d1
by have /on_topP := move_on_topr c1Mc2 c1Dc2; apply.
Qed.

Lemma move_on_toprDl n (d d1 : disk n) (c1 c2 : configuration n) : 
  move c1 c2 -> c1 d != c2 d -> d1 <= d -> c2 d1 != c1 d.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
move c1 c2 -> c1 d != c2 d -> d1 <= d -> c2 d1 != c1 d
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
move c1 c2 -> c1 d != c2 d -> d1 <= d -> c2 d1 != c1 d
move=> c1Mc2 c1Dc2; rewrite leq_eqVlt => /orP[/val_eqP->//|dLd1].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
c2 d != c1 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d
c2 d1 != c1 d
  by rewrite eq_sym.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d
c2 d1 != c1 d
move: (dLd1); rewrite ltnNge -(move_disk1 c1Mc2 c1Dc2) eq_sym //; last first.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d
d1 != d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d
~~ (d <= d1) -> c1 d != c1 d1
  by rewrite neq_ltn dLd1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d
~~ (d <= d1) -> c1 d != c1 d1
apply: contra => /eqP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d
c1 d = c1 d1 -> d <= d1
have /on_topP := move_on_topl c1Mc2 c1Dc2; apply.
Qed.

(* configuration on different pegs *)
Definition cdisjoint m n (c1 : configuration m) (c2 : configuration n) :=
  [forall i, [forall j, c1 i != c2 j]].

Lemma cdisjointP m n (c1 : configuration m) (c2 : configuration n) :
  reflect (forall i j, c1 i != c2 j) (cdisjoint c1 c2).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
reflect
  (forall (i : ordinal_finType m)
     (j : ordinal_finType n), c1 i != c2 j)
  (cdisjoint c1 c2)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
reflect
  (forall (i : ordinal_finType m)
     (j : ordinal_finType n), c1 i != c2 j)
  (cdisjoint c1 c2)
apply: (iffP forallP) => [H i j| H i].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
H:forall x : ordinal_finType m,
[forall j, c1 x != c2 j]
i:ordinal_finType m
j:ordinal_finType n
c1 i != c2 j
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
H:forall (i : ordinal_finType m)
  (j : ordinal_finType n), 
c1 i != c2 j
i:ordinal_finType m
[forall j, c1 i != c2 j]
  by move/forallP : (H i); apply.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
H:forall (i : ordinal_finType m)
  (j : ordinal_finType n), 
c1 i != c2 j
i:ordinal_finType m
[forall j, c1 i != c2 j]
by apply/forallP=> j; apply: H.
Qed.

(* merging two configurations : c1 for the small disks, c2 for the big ones   *)
Definition cmerge m n (c1 : configuration m) (c2 : configuration n) :=
  [ffun i => match tsplit i with inl j => c1 j | inr j => c2 j end].

(* right shifting a configuration : taking the disks smaller than n           *)
Definition crshift m n (c : configuration (m + n)) : configuration n := 
   [ffun i => c (trshift m i)].

(* left shifting a configuration : taking the disks larger than n             *)
Definition clshift m n (c : configuration (m + n)) : configuration m := 
   [ffun i => c (tlshift n i)].

(* Sanity check                                                               *)
Lemma cmergeK m n (c : configuration (m + n)) :
  cmerge (clshift c) (crshift c) = c.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
cmerge (clshift c) (crshift c) = c
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
cmerge (clshift c) (crshift c) = c
apply/ffunP=> i; rewrite !ffunE.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
i:ordinal_finType (m + n)
match tsplit i with
| inl j => clshift c j
| inr j => crshift c j
end = c i
by case: tsplitP => [] j iE; rewrite !ffunE /=;
   congr fun_of_fin; apply/val_eqP/eqP.
Qed.

Lemma tsplit_tlshift k m (x : 'I_k) : tsplit (tlshift m x) = inl x.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x:'I_k
tsplit (tlshift m x) = inl x
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x:'I_k
tsplit (tlshift m x) = inl x
case: tsplitP=> [j /= jE|k1 /= /eqP].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x:'I_k
j:'I_m
jE:x + m = j
inr j = inl x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x, k1:'I_k
x + m == k1 + m -> inl k1 = inl x
  by have := ltn_ord j; rewrite -jE ltnNge leq_addl.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x, k1:'I_k
x + m == k1 + m -> inl k1 = inl x
rewrite eqn_add2r => /eqP H.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x, k1:'I_k
H:x = k1
inl k1 = inl x
by congr (inl _); apply: val_inj.
Qed.

Lemma tsplit_trshift k m (x : 'I_k) : tsplit (trshift m x) = inr x.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x:'I_k
tsplit (trshift m x) = inr x
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x:'I_k
tsplit (trshift m x) = inr x
case: tsplitP => [j /= jE|k1 /= xE].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x, j:'I_k
jE:x = j
inr j = inr x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x:'I_k
k1:'I_m
xE:x = k1 + k
inl k1 = inr x
  by congr (inr _); apply: val_inj.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x:'I_k
k1:'I_m
xE:x = k1 + k
inl k1 = inr x
by have := ltn_ord x; rewrite xE ltnNge leq_addl.
Qed.

Lemma on_top_merger m n x (c1 : configuration m) (c2 : configuration n) : 
  on_top (trshift m x) (cmerge c1 c2) = on_top x c2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
on_top (trshift m x) (cmerge c1 c2) = on_top x c2
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
on_top (trshift m x) (cmerge c1 c2) = on_top x c2
apply/on_topP/on_topP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
(forall d1 : ordinal_finType (m + n),
 cmerge c1 c2 (trshift m x) = cmerge c1 c2 d1 ->
 trshift m x <= d1) ->
forall d1 : ordinal_finType n, c2 x = c2 d1 -> x <= d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
(forall d1 : ordinal_finType n,
 c2 x = c2 d1 -> x <= d1) ->
forall d1 : ordinal_finType (m + n),
cmerge c1 c2 (trshift m x) = cmerge c1 c2 d1 ->
trshift m x <= d1
  move=> Hx d2 cxEcd2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
Hx:forall d1 : ordinal_finType (m + n),
cmerge c1 c2 (trshift m x) = cmerge c1 c2 d1 ->
trshift m x <= d1
d2:ordinal_finType n
cxEcd2:c2 x = c2 d2
x <= d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
(forall d1 : ordinal_finType n,
 c2 x = c2 d1 -> x <= d1) ->
forall d1 : ordinal_finType (m + n),
cmerge c1 c2 (trshift m x) = cmerge c1 c2 d1 ->
trshift m x <= d1
  have := Hx (trshift m d2).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
Hx:forall d1 : ordinal_finType (m + n),
cmerge c1 c2 (trshift m x) = cmerge c1 c2 d1 ->
trshift m x <= d1
d2:ordinal_finType n
cxEcd2:c2 x = c2 d2
(cmerge c1 c2 (trshift m x) =
 cmerge c1 c2 (trshift m d2) ->
 trshift m x <= trshift m d2) -> x <= d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
(forall d1 : ordinal_finType n,
 c2 x = c2 d1 -> x <= d1) ->
forall d1 : ordinal_finType (m + n),
cmerge c1 c2 (trshift m x) = cmerge c1 c2 d1 ->
trshift m x <= d1
  by rewrite !ffunE !tsplit_trshift => /(_ cxEcd2).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
(forall d1 : ordinal_finType n,
 c2 x = c2 d1 -> x <= d1) ->
forall d1 : ordinal_finType (m + n),
cmerge c1 c2 (trshift m x) = cmerge c1 c2 d1 ->
trshift m x <= d1
move=> H d; rewrite !ffunE tsplit_trshift /=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
H:forall d1 : ordinal_finType n,
c2 x = c2 d1 -> x <= d1
d:ordinal_finType (m + n)
c2 x =
match tsplit d with
| inl j => c1 j
| inr j => c2 j
end -> x <= d
case: tsplitP => [j -> H1 | k -> _].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
H:forall d1 : ordinal_finType n,
c2 x = c2 d1 -> x <= d1
d:ordinal_finType (m + n)
j:'I_n
H1:c2 x = c2 j
x <= j
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
H:forall d1 : ordinal_finType n,
c2 x = c2 d1 -> x <= d1
d:ordinal_finType (m + n)
k:'I_m
x <= k + n
  by apply: H.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
H:forall d1 : ordinal_finType n,
c2 x = c2 d1 -> x <= d1
d:ordinal_finType (m + n)
k:'I_m
x <= k + n
by apply: leq_trans (ltnW _) (leq_addl _ _).
Qed.

Lemma move_merger m n (c : configuration n) (c1 c2 : configuration m) :
    move (cmerge c c1) (cmerge c c2) = move c1 c2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
move (cmerge c c1) (cmerge c c2) = move c1 c2
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
move (cmerge c c1) (cmerge c c2) = move c1 c2
apply/moveP/moveP => [] [d1 [H1d1 H2d1 H3d1 H4d1]]; last first.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType m
H1d1:r (c1 d1) (c2 d1)
H2d1:forall d2 : ordinal_finType m,
d1 != d2 -> c1 d2 = c2 d2
H3d1:on_top d1 c1
H4d1:on_top d1 c2
exists d1 : ordinal_finType (n + m),
  [/\ r (cmerge c c1 d1) (cmerge c c2 d1),
      forall d2 : ordinal_finType (n + m),
      d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2,
      on_top d1 (cmerge c c1)
    & on_top d1 (cmerge c c2)]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H1d1:r (cmerge c c1 d1) (cmerge c c2 d1)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
exists d1 : ordinal_finType m,
  [/\ r (c1 d1) (c2 d1),
      forall d2 : ordinal_finType m,
      d1 != d2 -> c1 d2 = c2 d2, 
     on_top d1 c1
    & on_top d1 c2]
  exists (trshift n d1); split => //; try by rewrite on_top_merger.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType m
H1d1:r (c1 d1) (c2 d1)
H2d1:forall d2 : ordinal_finType m,
d1 != d2 -> c1 d2 = c2 d2
H3d1:on_top d1 c1
H4d1:on_top d1 c2
r (cmerge c c1 (trshift n d1))
  (cmerge c c2 (trshift n d1))
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType m
H1d1:r (c1 d1) (c2 d1)
H2d1:forall d2 : ordinal_finType m,
d1 != d2 -> c1 d2 = c2 d2
H3d1:on_top d1 c1
H4d1:on_top d1 c2
forall d2 : ordinal_finType (n + m),
trshift n d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H1d1:r (cmerge c c1 d1) (cmerge c c2 d1)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
exists d1 : ordinal_finType m,
  [/\ r (c1 d1) (c2 d1),
      forall d2 : ordinal_finType m,
      d1 != d2 -> c1 d2 = c2 d2, 
     on_top d1 c1
    & on_top d1 c2]
    by rewrite !ffunE /= tsplit_trshift.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType m
H1d1:r (c1 d1) (c2 d1)
H2d1:forall d2 : ordinal_finType m,
d1 != d2 -> c1 d2 = c2 d2
H3d1:on_top d1 c1
H4d1:on_top d1 c2
forall d2 : ordinal_finType (n + m),
trshift n d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H1d1:r (cmerge c c1 d1) (cmerge c c2 d1)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
exists d1 : ordinal_finType m,
  [/\ r (c1 d1) (c2 d1),
      forall d2 : ordinal_finType m,
      d1 != d2 -> c1 d2 = c2 d2, 
     on_top d1 c1
    & on_top d1 c2]
  move=> d2; rewrite !ffunE; case: tsplitP => // k d2E H.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType m
H1d1:r (c1 d1) (c2 d1)
H2d1:forall d2 : ordinal_finType m,
d1 != d2 -> c1 d2 = c2 d2
H3d1:on_top d1 c1
H4d1:on_top d1 c2
d2:ordinal_finType (n + m)
k:'I_m
d2E:d2 = k
H:trshift n d1 != d2
c1 k = c2 k
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H1d1:r (cmerge c c1 d1) (cmerge c c2 d1)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
exists d1 : ordinal_finType m,
  [/\ r (c1 d1) (c2 d1),
      forall d2 : ordinal_finType m,
      d1 != d2 -> c1 d2 = c2 d2, 
     on_top d1 c1
    & on_top d1 c2]
  apply: H2d1 => //; apply: contra H => /eqP->.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType m
H1d1:r (c1 d1) (c2 d1)
H3d1:on_top d1 c1
H4d1:on_top d1 c2
d2:ordinal_finType (n + m)
k:'I_m
d2E:d2 = k
trshift n k == d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H1d1:r (cmerge c c1 d1) (cmerge c c2 d1)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
exists d1 : ordinal_finType m,
  [/\ r (c1 d1) (c2 d1),
      forall d2 : ordinal_finType m,
      d1 != d2 -> c1 d2 = c2 d2, 
     on_top d1 c1
    & on_top d1 c2]
  by apply/eqP/val_eqP/eqP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H1d1:r (cmerge c c1 d1) (cmerge c c2 d1)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
exists d1 : ordinal_finType m,
  [/\ r (c1 d1) (c2 d1),
      forall d2 : ordinal_finType m,
      d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1
    & on_top d1 c2]
move: H1d1; rewrite !ffunE.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
r
  match tsplit d1 with
  | inl j => c j
  | inr j => c1 j
  end
  match tsplit d1 with
  | inl j => c j
  | inr j => c2 j
  end ->
exists d1 : ordinal_finType m,
  [/\ r (c1 d1) (c2 d1),
      forall d2 : ordinal_finType m,
      d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1
    & on_top d1 c2]
case: tsplitP => [j jE H1x|k _]; last by rewrite irH.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
exists d1 : ordinal_finType m,
  [/\ r (c1 d1) (c2 d1),
      forall d2 : ordinal_finType m,
      d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1
    & on_top d1 c2]
have d1E : (trshift n j) = d1 by apply/val_eqP/eqP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1
exists d1 : ordinal_finType m,
  [/\ r (c1 d1) (c2 d1),
      forall d2 : ordinal_finType m,
      d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1
    & on_top d1 c2]
rewrite -d1E in H3d1 H4d1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1
H3d1:on_top (trshift n j) (cmerge c c1)
H4d1:on_top (trshift n j) (cmerge c c2)
exists d1 : ordinal_finType m,
  [/\ r (c1 d1) (c2 d1),
      forall d2 : ordinal_finType m,
      d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1
    & on_top d1 c2]
exists j; split => //; try by rewrite -(on_top_merger _ c).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1
H3d1:on_top (trshift n j) (cmerge c c1)
H4d1:on_top (trshift n j) (cmerge c c2)
forall d2 : ordinal_finType m,
j != d2 -> c1 d2 = c2 d2
move=> d2 kDd2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1
H3d1:on_top (trshift n j) (cmerge c c1)
H4d1:on_top (trshift n j) (cmerge c c2)
d2:ordinal_finType m
kDd2:j != d2
c1 d2 = c2 d2
have := H2d1 (trshift n d2).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1
H3d1:on_top (trshift n j) (cmerge c c1)
H4d1:on_top (trshift n j) (cmerge c c2)
d2:ordinal_finType m
kDd2:j != d2
(d1 != trshift n d2 ->
 cmerge c c1 (trshift n d2) =
 cmerge c c2 (trshift n d2)) -> c1 d2 = c2 d2
rewrite !ffunE tsplit_trshift => H.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1
H3d1:on_top (trshift n j) (cmerge c c1)
H4d1:on_top (trshift n j) (cmerge c c2)
d2:ordinal_finType m
kDd2:j != d2
H:d1 != trshift n d2 -> c1 d2 = c2 d2
c1 d2 = c2 d2
apply: H.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1
H3d1:on_top (trshift n j) (cmerge c c1)
H4d1:on_top (trshift n j) (cmerge c c2)
d2:ordinal_finType m
kDd2:j != d2
d1 != trshift n d2
apply: contra kDd2 => /eqP/val_eqP /=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m),
d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1
H3d1:on_top (trshift n j) (cmerge c c1)
H4d1:on_top (trshift n j) (cmerge c c2)
d2:ordinal_finType m
d1 == d2 -> j == d2
by rewrite jE.
Qed.

Lemma path_merger m n (c1 : configuration m)
         (c2 : configuration n) (cs : seq (configuration _)) :
    path move (cmerge c1 c2) [seq cmerge c1 c | c <- cs]  = 
    path move c2 cs.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
cs:seq (configuration n)
path move (cmerge c1 c2) [seq cmerge c1 c | c <- cs] =
path move c2 cs
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
cs:seq (configuration n)
path move (cmerge c1 c2) [seq cmerge c1 c | c <- cs] =
path move c2 cs by elim: cs c2 => //= c3 cs IH c2; rewrite move_merger IH. Qed.

Lemma connect_merger m n (c : configuration m) (c1 c2 : configuration n) : 
  connect move c1 c2 -> connect move (cmerge c c1) (cmerge c c2).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n
connect move c1 c2 ->
connect move (cmerge c c1) (cmerge c c2)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n
connect move c1 c2 ->
connect move (cmerge c c1) (cmerge c c2)
move=> /connectP[x]; rewrite -(path_merger c) => Hp Hl.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n
x:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType q))
Hp:path move (cmerge c c1)
  [seq cmerge c c0 | c0 <- x]
Hl:c2 = last c1 x
connect move (cmerge c c1) (cmerge c c2)
apply/connectP; eexists; first exact: Hp.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n
x:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType q))
Hp:path move (cmerge c c1)
  [seq cmerge c c0 | c0 <- x]
Hl:c2 = last c1 x
cmerge c c2 =
last (cmerge c c1) [seq cmerge c c0 | c0 <- x]
by rewrite Hl [RHS]last_map.
Qed.

(* this should be equality                                                    *)
Lemma gdist_merger m n (c: configuration m) (c1 c2 : configuration n) : 
  connect move c1 c2 ->
  `d[cmerge c c1, cmerge c c2]_move <= `d[c1, c2]_move.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n
connect move c1 c2 ->
`d[cmerge c c1, cmerge c c2]_move <= `d[c1, c2]_move
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n
connect move c1 c2 ->
`d[cmerge c c1, cmerge c c2]_move <= `d[c1, c2]_move
move=> /gpath_connect[p1 p1H].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n
p1:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType q))
p1H:gpath move c1 c2 p1
`d[cmerge c c1, cmerge c c2]_move <= `d[c1, c2]_move
rewrite (gpath_dist p1H) -(size_map (cmerge c)).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n
p1:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType q))
p1H:gpath move c1 c2 p1
`d[cmerge c c1, cmerge c c2]_move <=
size [seq cmerge c i | i <- p1]
apply: gdist_path_le; first by rewrite path_merger (gpath_path p1H).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n
p1:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType q))
p1H:gpath move c1 c2 p1
last (cmerge c c1) [seq cmerge c i | i <- p1] =
cmerge c c2
by rewrite [LHS]last_map (gpath_last p1H).
Qed.

Lemma on_top_mergel m n (c1 : configuration m) (c2 : configuration n) d :
  cdisjoint c1 c2 -> on_top d c1 -> on_top (tlshift n d) (cmerge c1 c2).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:disk m
cdisjoint c1 c2 ->
on_top d c1 -> on_top (tlshift n d) (cmerge c1 c2)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:disk m
cdisjoint c1 c2 ->
on_top d c1 -> on_top (tlshift n d) (cmerge c1 c2)
move=> c1Dc2 /on_topP dTc; apply/on_topP => d1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:disk m
c1Dc2:cdisjoint c1 c2
dTc:forall d1 : ordinal_finType m,
c1 d = c1 d1 -> d <= d1
d1:ordinal_finType (m + n)
cmerge c1 c2 (tlshift n d) = cmerge c1 c2 d1 ->
tlshift n d <= d1
rewrite !ffunE tsplit_tlshift /=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:disk m
c1Dc2:cdisjoint c1 c2
dTc:forall d1 : ordinal_finType m,
c1 d = c1 d1 -> d <= d1
d1:ordinal_finType (m + n)
c1 d =
match tsplit d1 with
| inl j => c1 j
| inr j => c2 j
end -> d + n <= d1
case: tsplitP => j -> c1dc1j; last first.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:disk m
c1Dc2:cdisjoint c1 c2
dTc:forall d1 : ordinal_finType m,
c1 d = c1 d1 -> d <= d1
d1:ordinal_finType (m + n)
j:'I_m
c1dc1j:c1 d = c1 j
d + n <= j + n
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:disk m
c1Dc2:cdisjoint c1 c2
dTc:forall d1 : ordinal_finType m,
c1 d = c1 d1 -> d <= d1
d1:ordinal_finType (m + n)
j:'I_n
c1dc1j:c1 d = c2 j
d + n <= j
  by rewrite leq_add2r; apply: dTc.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:disk m
c1Dc2:cdisjoint c1 c2
dTc:forall d1 : ordinal_finType m,
c1 d = c1 d1 -> d <= d1
d1:ordinal_finType (m + n)
j:'I_n
c1dc1j:c1 d = c2 j
d + n <= j
by have /cdisjointP/(_ d j)/eqP[] := c1Dc2.
Qed.

Lemma on_top_mergel_inv m n (c1 : configuration m) (c2 : configuration n) d :
  on_top (tlshift n d) (cmerge c1 c2) -> on_top d c1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:'I_m
on_top (tlshift n d) (cmerge c1 c2) -> on_top d c1
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:'I_m
on_top (tlshift n d) (cmerge c1 c2) -> on_top d c1
move=> /on_topP dTc; apply/on_topP => d1 Hc.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:'I_m
dTc:forall d1 : ordinal_finType (m + n),
cmerge c1 c2 (tlshift n d) = cmerge c1 c2 d1 ->
tlshift n d <= d1
d1:ordinal_finType m
Hc:c1 d = c1 d1
d <= d1
have := dTc (tlshift n d1).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:'I_m
dTc:forall d1 : ordinal_finType (m + n),
cmerge c1 c2 (tlshift n d) = cmerge c1 c2 d1 ->
tlshift n d <= d1
d1:ordinal_finType m
Hc:c1 d = c1 d1
(cmerge c1 c2 (tlshift n d) =
 cmerge c1 c2 (tlshift n d1) ->
 tlshift n d <= tlshift n d1) -> d <= d1
by rewrite !ffunE !tsplit_tlshift /= leq_add2r; apply.
Qed.

Lemma move_mergel m n (c1 c2 : configuration m) (c : configuration n) :
  move (cmerge c1 c) (cmerge c2 c) -> move c1 c2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
move (cmerge c1 c) (cmerge c2 c) -> move c1 c2
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
move (cmerge c1 c) (cmerge c2 c) -> move c1 c2
move=> /moveP [x [H1x H2x H3x H4x]]; apply/moveP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H1x:r (cmerge c1 c x) (cmerge c2 c x)
H2x:forall d2 : ordinal_finType (m + n),
x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
H3x:on_top x (cmerge c1 c)
H4x:on_top x (cmerge c2 c)
exists d1 : ordinal_finType m,
  [/\ r (c1 d1) (c2 d1),
      forall d2 : ordinal_finType m,
      d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1
    & on_top d1 c2]
move: H1x; rewrite !ffunE.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n),
x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
H3x:on_top x (cmerge c1 c)
H4x:on_top x (cmerge c2 c)
r
  match tsplit x with
  | inl j => c1 j
  | inr j => c j
  end
  match tsplit x with
  | inl j => c2 j
  | inr j => c j
  end ->
exists d1 : ordinal_finType m,
  [/\ r (c1 d1) (c2 d1),
      forall d2 : ordinal_finType m,
      d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1
    & on_top d1 c2]
case: tsplitP => [j | k kE J1x]; first by rewrite irH.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n),
x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
H3x:on_top x (cmerge c1 c)
H4x:on_top x (cmerge c2 c)
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
exists d1 : ordinal_finType m,
  [/\ r (c1 d1) (c2 d1),
      forall d2 : ordinal_finType m,
      d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1
    & on_top d1 c2]
have xE : (tlshift n k) = x by apply/val_eqP/eqP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n),
x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
H3x:on_top x (cmerge c1 c)
H4x:on_top x (cmerge c2 c)
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x
exists d1 : ordinal_finType m,
  [/\ r (c1 d1) (c2 d1),
      forall d2 : ordinal_finType m,
      d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1
    & on_top d1 c2]
rewrite -xE in H3x H4x.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n),
x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x
H3x:on_top (tlshift n k) (cmerge c1 c)
H4x:on_top (tlshift n k) (cmerge c2 c)
exists d1 : ordinal_finType m,
  [/\ r (c1 d1) (c2 d1),
      forall d2 : ordinal_finType m,
      d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1
    & on_top d1 c2]
exists k; split => //; try by apply: on_top_mergel_inv; eassumption.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n),
x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x
H3x:on_top (tlshift n k) (cmerge c1 c)
H4x:on_top (tlshift n k) (cmerge c2 c)
forall d2 : ordinal_finType m,
k != d2 -> c1 d2 = c2 d2
move=> d2 kDd2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n),
x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x
H3x:on_top (tlshift n k) (cmerge c1 c)
H4x:on_top (tlshift n k) (cmerge c2 c)
d2:ordinal_finType m
kDd2:k != d2
c1 d2 = c2 d2
have := H2x (tlshift n d2).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n),
x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x
H3x:on_top (tlshift n k) (cmerge c1 c)
H4x:on_top (tlshift n k) (cmerge c2 c)
d2:ordinal_finType m
kDd2:k != d2
(x != tlshift n d2 ->
 cmerge c1 c (tlshift n d2) =
 cmerge c2 c (tlshift n d2)) -> c1 d2 = c2 d2
rewrite !ffunE tsplit_tlshift => H.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n),
x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x
H3x:on_top (tlshift n k) (cmerge c1 c)
H4x:on_top (tlshift n k) (cmerge c2 c)
d2:ordinal_finType m
kDd2:k != d2
H:x != tlshift n d2 -> c1 d2 = c2 d2
c1 d2 = c2 d2
apply: H.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n),
x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x
H3x:on_top (tlshift n k) (cmerge c1 c)
H4x:on_top (tlshift n k) (cmerge c2 c)
d2:ordinal_finType m
kDd2:k != d2
x != tlshift n d2
apply: contra kDd2 => /eqP/val_eqP /=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n),
x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x
H3x:on_top (tlshift n k) (cmerge c1 c)
H4x:on_top (tlshift n k) (cmerge c2 c)
d2:ordinal_finType m
x == d2 + n -> k == d2
by rewrite kE eqn_add2r.
Qed.

Lemma move_mergel_inv m n (c1 c2 : configuration m) 
                          (c : configuration n) :
  cdisjoint c1 c -> cdisjoint c2 c ->
  move c1 c2 -> move (cmerge c1 c) (cmerge c2 c).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
cdisjoint c1 c ->
cdisjoint c2 c ->
move c1 c2 -> move (cmerge c1 c) (cmerge c2 c)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
cdisjoint c1 c ->
cdisjoint c2 c ->
move c1 c2 -> move (cmerge c1 c) (cmerge c2 c)
move=> c1Dc c2Dc /moveP[x [H1x H2x H3x H4x]]; apply/moveP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
c1Dc:cdisjoint c1 c
c2Dc:cdisjoint c2 c
x:ordinal_finType m
H1x:r (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType m,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
exists d1 : ordinal_finType (m + n),
  [/\ r (cmerge c1 c d1) (cmerge c2 c d1),
      forall d2 : ordinal_finType (m + n),
      d1 != d2 -> cmerge c1 c d2 = cmerge c2 c d2,
      on_top d1 (cmerge c1 c)
    & on_top d1 (cmerge c2 c)]
exists (tlshift n x); split => //; try by apply/on_top_mergel.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
c1Dc:cdisjoint c1 c
c2Dc:cdisjoint c2 c
x:ordinal_finType m
H1x:r (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType m,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r (cmerge c1 c (tlshift n x))
  (cmerge c2 c (tlshift n x))
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
c1Dc:cdisjoint c1 c
c2Dc:cdisjoint c2 c
x:ordinal_finType m
H1x:r (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType m,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType (m + n),
tlshift n x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
  by rewrite !ffunE /= tsplit_tlshift.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
c1Dc:cdisjoint c1 c
c2Dc:cdisjoint c2 c
x:ordinal_finType m
H1x:r (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType m,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType (m + n),
tlshift n x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
move=> d2; rewrite !ffunE; case: tsplitP => // k d2E H.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
c1Dc:cdisjoint c1 c
c2Dc:cdisjoint c2 c
x:ordinal_finType m
H1x:r (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType m,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
d2:ordinal_finType (m + n)
k:'I_m
d2E:d2 = k + n
H:tlshift n x != d2
c1 k = c2 k
apply: H2x => //; apply: contra H => /eqP->.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
c1Dc:cdisjoint c1 c
c2Dc:cdisjoint c2 c
x:ordinal_finType m
H1x:r (c1 x) (c2 x)
H3x:on_top x c1
H4x:on_top x c2
d2:ordinal_finType (m + n)
k:'I_m
d2E:d2 = k + n
tlshift n k == d2
by apply/eqP/val_eqP/eqP.
Qed.

Lemma path_mergel m n (c1 : configuration m)
         (c2 : configuration n) (cs : seq (configuration _)) :
    path move (cmerge c1 c2) [seq cmerge i c2 | i <- cs] -> 
    path move c1 cs.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
cs:seq (configuration m)
path move (cmerge c1 c2) [seq cmerge i c2 | i <- cs] ->
path move c1 cs
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
cs:seq (configuration m)
path move (cmerge c1 c2) [seq cmerge i c2 | i <- cs] ->
path move c1 cs by elim: cs c1 => //= c3 cs IH c1 /andP[/move_mergel-> /IH]. Qed.

Lemma path_mergel_inv m n (c1 : configuration m)
         (c2 : configuration n) (cs : seq (configuration _)) :
    all (fun i => cdisjoint i c2) (c1 :: cs) ->
    path move c1 cs ->
    path move (cmerge c1 c2) [seq cmerge i c2 | i <- cs].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
cs:seq (configuration m)
all ((cdisjoint (n:=n))^~ c2) (c1 :: cs) ->
path move c1 cs ->
path move (cmerge c1 c2) [seq cmerge i c2 | i <- cs]
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
cs:seq (configuration m)
all ((cdisjoint (n:=n))^~ c2) (c1 :: cs) ->
path move c1 cs ->
path move (cmerge c1 c2) [seq cmerge i c2 | i <- cs]
elim: cs c1 => //= c3 cs IH c1 /and3P[c1Dc2 c3Dc2 Dcs] 
                               /andP[/move_mergel_inv ->// /IH->//].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c2:configuration n
c3:configuration m
cs:seq (configuration m)
IH:forall c1 : configuration m,
cdisjoint c1 c2 &&
all ((cdisjoint (n:=n))^~ c2) cs ->
path move c1 cs ->
path move (cmerge c1 c2)
  [seq cmerge i c2 | i <- cs]
c1:configuration m
c1Dc2:cdisjoint c1 c2
c3Dc2:cdisjoint c3 c2
Dcs:all ((cdisjoint (n:=n))^~ c2) cs
cdisjoint c3 c2 && all ((cdisjoint (n:=n))^~ c2) cs
by rewrite c3Dc2.
Qed.

Lemma on_top_shift m n (c : configuration (m + n)) d :
  on_top d c -> 
  match tsplit d with
  | inl d1 => on_top d1 (clshift c)
  | inr d2 => on_top d2 (crshift c)
  end.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
d:disk (m + n)
on_top d c ->
match tsplit d with
| inl d1 => on_top d1 (clshift c)
| inr d2 => on_top d2 (crshift c)
end
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
d:disk (m + n)
on_top d c ->
match tsplit d with
| inl d1 => on_top d1 (clshift c)
| inr d2 => on_top d2 (crshift c)
end
rewrite -{1}[d](tsplitK d).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
d:disk (m + n)
on_top (tunsplit (tsplit d)) c ->
match tsplit d with
| inl d1 => on_top d1 (clshift c)
| inr d2 => on_top d2 (crshift c)
end
case: tsplitP => /= j dE /on_topP /= dT; 
    apply/on_topP => d1; rewrite !ffunE /= => H.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
d:disk (m + n)
j:'I_n
dE:d = j
dT:forall d1 : 'I_(m + n),
c (trshift m j) = c d1 -> j <= d1
d1:ordinal_finType n
H:c (trshift m j) = c (trshift m d1)
j <= d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
d:disk (m + n)
j:'I_m
dE:d = j + n
dT:forall d1 : 'I_(m + n),
c (tlshift n j) = c d1 -> j + n <= d1
d1:ordinal_finType m
H:c (tlshift n j) = c (tlshift n d1)
j <= d1
 by apply: dT H.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
d:disk (m + n)
j:'I_m
dE:d = j + n
dT:forall d1 : 'I_(m + n),
c (tlshift n j) = c d1 -> j + n <= d1
d1:ordinal_finType m
H:c (tlshift n j) = c (tlshift n d1)
j <= d1
by have /= := dT _ H; rewrite leq_add2r.
Qed.

Lemma move_clshift m n (c1 c2 : configuration (m + n)) : 
  move c1 c2 -> (clshift c1) != (clshift c2) ->
  move (clshift c1) (clshift c2).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
move c1 c2 ->
clshift c1 != clshift c2 ->
move (clshift c1) (clshift c2)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
move c1 c2 ->
clshift c1 != clshift c2 ->
move (clshift c1) (clshift c2)
move=> /moveP [x].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
[/\ r (c1 x) (c2 x),
    forall d2 : ordinal_finType (m + n),
    x != d2 -> c1 d2 = c2 d2, on_top x c1
  & on_top x c2] ->
clshift c1 != clshift c2 ->
move (clshift c1) (clshift c2)
rewrite -(tsplitK x).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
[/\ r (c1 (tunsplit (tsplit x)))
      (c2 (tunsplit (tsplit x))),
    forall d2 : ordinal_finType (m + n),
    tunsplit (tsplit x) != d2 -> c1 d2 = c2 d2,
    on_top (tunsplit (tsplit x)) c1
  & on_top (tunsplit (tsplit x)) c2] ->
clshift c1 != clshift c2 ->
move (clshift c1) (clshift c2)
have := @on_top_shift _ _ c1 x.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
(on_top x c1 ->
 match tsplit x with
 | inl d1 => on_top d1 (clshift c1)
 | inr d2 => on_top d2 (crshift c1)
 end) ->
[/\ r (c1 (tunsplit (tsplit x)))
      (c2 (tunsplit (tsplit x))),
    forall d2 : ordinal_finType (m + n),
    tunsplit (tsplit x) != d2 -> c1 d2 = c2 d2,
    on_top (tunsplit (tsplit x)) c1
  & on_top (tunsplit (tsplit x)) c2] ->
clshift c1 != clshift c2 ->
move (clshift c1) (clshift c2)
have := @on_top_shift _ _ c2 x.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
(on_top x c2 ->
 match tsplit x with
 | inl d1 => on_top d1 (clshift c2)
 | inr d2 => on_top d2 (crshift c2)
 end) ->
(on_top x c1 ->
 match tsplit x with
 | inl d1 => on_top d1 (clshift c1)
 | inr d2 => on_top d2 (crshift c1)
 end) ->
[/\ r (c1 (tunsplit (tsplit x)))
      (c2 (tunsplit (tsplit x))),
    forall d2 : ordinal_finType (m + n),
    tunsplit (tsplit x) != d2 -> c1 d2 = c2 d2,
    on_top (tunsplit (tsplit x)) c1
  & on_top (tunsplit (tsplit x)) c2] ->
clshift c1 != clshift c2 ->
move (clshift c1) (clshift c2)
case: tsplitP => /= [j xE c2H c1H [H1j H2j H3j H4j] c1Dc2|
                      k xE c2H c1H [H1k H2k H3k H4k] c1Dc2].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:clshift c1 != clshift c2
move (clshift c1) (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
move (clshift c1) (clshift c2)
  case/eqP: c1Dc2; apply/ffunP => i.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
i:ordinal_finType m
clshift c1 i = clshift c2 i
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
move (clshift c1) (clshift c2)
  rewrite !ffunE.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
i:ordinal_finType m
c1 (tlshift n i) = c2 (tlshift n i)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
move (clshift c1) (clshift c2)
  apply/H2j/eqP/val_eqP; rewrite eqn_leq /= negb_and.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
i:ordinal_finType m
~~ (j <= i + n) || ~~ (i + n <= j)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
move (clshift c1) (clshift c2)
  by rewrite orbC -ltnNge (leq_trans (ltn_ord _)) // leq_addl.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
move (clshift c1) (clshift c2)
apply/moveP; exists k; split=> [|d2 kDd2||]; rewrite ?ffunE //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
d2:ordinal_finType m
kDd2:k != d2
c1 (tlshift n d2) = c2 (tlshift n d2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c2)
-
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
d2:ordinal_finType m
kDd2:k != d2
c1 (tlshift n d2) = c2 (tlshift n d2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c2) apply: H2k => /=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
d2:ordinal_finType m
kDd2:k != d2
tlshift n k != tlshift n d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c2)
  by apply/eqP/val_eqP; rewrite /= eqn_add2r; apply/val_eqP/eqP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c2)
-
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c2) apply: c1H; rewrite (_ : x = (tlshift n k)) //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
x = tlshift n k
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c2)
  by apply/val_eqP/eqP => /=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c2)
apply: c2H; rewrite (_ : x = (tlshift n k)) //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
x = tlshift n k
by apply/val_eqP/eqP => /=.
Qed.

Lemma move_crshift m n (c1 c2 : configuration (m + n)) : 
  move c1 c2 -> (crshift c1) != (crshift c2) ->
  move (crshift c1) (crshift c2).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
move c1 c2 ->
crshift c1 != crshift c2 ->
move (crshift c1) (crshift c2)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
move c1 c2 ->
crshift c1 != crshift c2 ->
move (crshift c1) (crshift c2)
move=> /moveP [x].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
[/\ r (c1 x) (c2 x),
    forall d2 : ordinal_finType (m + n),
    x != d2 -> c1 d2 = c2 d2, on_top x c1
  & on_top x c2] ->
crshift c1 != crshift c2 ->
move (crshift c1) (crshift c2)
rewrite -(tsplitK x).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
[/\ r (c1 (tunsplit (tsplit x)))
      (c2 (tunsplit (tsplit x))),
    forall d2 : ordinal_finType (m + n),
    tunsplit (tsplit x) != d2 -> c1 d2 = c2 d2,
    on_top (tunsplit (tsplit x)) c1
  & on_top (tunsplit (tsplit x)) c2] ->
crshift c1 != crshift c2 ->
move (crshift c1) (crshift c2)
have := @on_top_shift _ _ c1 x.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
(on_top x c1 ->
 match tsplit x with
 | inl d1 => on_top d1 (clshift c1)
 | inr d2 => on_top d2 (crshift c1)
 end) ->
[/\ r (c1 (tunsplit (tsplit x)))
      (c2 (tunsplit (tsplit x))),
    forall d2 : ordinal_finType (m + n),
    tunsplit (tsplit x) != d2 -> c1 d2 = c2 d2,
    on_top (tunsplit (tsplit x)) c1
  & on_top (tunsplit (tsplit x)) c2] ->
crshift c1 != crshift c2 ->
move (crshift c1) (crshift c2)
have := @on_top_shift _ _ c2 x.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
(on_top x c2 ->
 match tsplit x with
 | inl d1 => on_top d1 (clshift c2)
 | inr d2 => on_top d2 (crshift c2)
 end) ->
(on_top x c1 ->
 match tsplit x with
 | inl d1 => on_top d1 (clshift c1)
 | inr d2 => on_top d2 (crshift c1)
 end) ->
[/\ r (c1 (tunsplit (tsplit x)))
      (c2 (tunsplit (tsplit x))),
    forall d2 : ordinal_finType (m + n),
    tunsplit (tsplit x) != d2 -> c1 d2 = c2 d2,
    on_top (tunsplit (tsplit x)) c1
  & on_top (tunsplit (tsplit x)) c2] ->
crshift c1 != crshift c2 ->
move (crshift c1) (crshift c2)
case: tsplitP => /= [j xE c2H c1H [H1j H2j H3j H4j] c1Dc2|
                      k xE c2H c1H [H1k H2k H3k H4k] c1Dc2]; last first.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:crshift c1 != crshift c2
move (crshift c1) (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
move (crshift c1) (crshift c2)
  case/eqP: c1Dc2; apply/ffunP => i.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
i:ordinal_finType n
crshift c1 i = crshift c2 i
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
move (crshift c1) (crshift c2)
  rewrite !ffunE.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
i:ordinal_finType n
c1 (trshift m i) = c2 (trshift m i)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
move (crshift c1) (crshift c2)
  apply/H2k/eqP/val_eqP; rewrite eqn_leq /= negb_and.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n),
tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
i:ordinal_finType n
~~ (k + n <= i) || ~~ (i <= k + n)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
move (crshift c1) (crshift c2)
  by rewrite -ltnNge  (leq_trans (ltn_ord _)) // leq_addl.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
move (crshift c1) (crshift c2)
apply/moveP; exists j; split=> [|d2 kDd2||]; rewrite ?ffunE //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
d2:ordinal_finType n
kDd2:j != d2
c1 (trshift m d2) = c2 (trshift m d2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c2)
-
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
d2:ordinal_finType n
kDd2:j != d2
c1 (trshift m d2) = c2 (trshift m d2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c2) by apply: H2j.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c2)
-
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c2) apply: c1H; rewrite (_ : x = (trshift m j)) //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
x = trshift m j
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c2)
  by apply/val_eqP/eqP => /=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c2)
apply: c2H; rewrite (_ : x = (trshift m j)) //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n),
trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
x = trshift m j
by apply/val_eqP/eqP => /=.
Qed.

Fixpoint rm_rep (A : eqType) (a : A) (s : seq A) := 
  if s is b :: s1 then 
    if a == b then rm_rep b s1 else b :: rm_rep b s1 
  else [::].

Lemma subseq_rm_rep (A : eqType) (a : A) s : subseq (rm_rep a s) s.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A
subseq (rm_rep a s) s
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A
subseq (rm_rep a s) s
elim: s a => // b s IH a.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b:A
s:seq A
IH:forall a : A, subseq (rm_rep a s) s
a:A
subseq (rm_rep a (b :: s)) (b :: s)
rewrite [rm_rep _ _]/=; case: (a == b).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b:A
s:seq A
IH:forall a : A, subseq (rm_rep a s) s
a:A
subseq (rm_rep b s) (b :: s)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b:A
s:seq A
IH:forall a : A, subseq (rm_rep a s) s
a:A
subseq (b :: rm_rep b s) (b :: s)
  by apply: subseq_trans (IH _) (subseq_cons _ _).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b:A
s:seq A
IH:forall a : A, subseq (rm_rep a s) s
a:A
subseq (b :: rm_rep b s) (b :: s)
by rewrite /= eqxx IH.
Qed.

Lemma subset_rm_rep (A : eqType) (a : A) s : {subset rm_rep a s <= s}.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A
{subset rm_rep a s <= s}
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A
{subset rm_rep a s <= s} by apply/mem_subseq/subseq_rm_rep. Qed.

Lemma size_rm_rep (A : eqType) (a : A) s : size (rm_rep a s) <= size s.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A
size (rm_rep a s) <= size s
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A
size (rm_rep a s) <= size s by apply/size_subseq/subseq_rm_rep. Qed.

Lemma size_rm_rep_cons (A : eqType) (a b : A) s : 
  size (rm_rep b s) <= size (rm_rep a (b :: s)).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a, b:A
s:seq A
size (rm_rep b s) <= size (rm_rep a (b :: s))
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a, b:A
s:seq A
size (rm_rep b s) <= size (rm_rep a (b :: s)) by rewrite /=; case: (_ == _) => //=. Qed.

Lemma size_rm_rep_subset  (A : finType) (a : A) (s1 : {set A}) (s2 : seq A) : 
  {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
a:A
s1:{set A}
s2:seq A
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
a:A
s1:{set A}
s2:seq A
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
elim: s2 s1 a => /= [s1 a aS _|b s2 IH s1 a s1S aNIs1].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
s1:{set A}
a:A
aS:{subset s1 <= [::]}
#|s1| <= 0
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
#|s1| <=
size
  (if a == b then rm_rep b s2 else b :: rm_rep b s2)
  rewrite leqn0 cards_eq0; apply/eqP/setP=> i.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
s1:{set A}
a:A
aS:{subset s1 <= [::]}
i:A
(i \in s1) = (i \in set0)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
#|s1| <=
size
  (if a == b then rm_rep b s2 else b :: rm_rep b s2)
  by rewrite inE; apply/idP => /aS.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
#|s1| <=
size
  (if a == b then rm_rep b s2 else b :: rm_rep b s2)
case: eqP=> [aEb|aDb].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aEb:a = b
#|s1| <= size (rm_rep b s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
#|s1| <= size (b :: rm_rep b s2)
  rewrite -aEb; apply: IH => //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aEb:a = b
{subset s1 <= s2}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
#|s1| <= size (b :: rm_rep b s2)
  move=> i is1; have := is1; have := s1S _ is1; rewrite inE.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aEb:a = b
i:A
is1:i \in s1
(i == b) || (i \in s2) -> i \in s1 -> i \in s2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
#|s1| <= size (b :: rm_rep b s2)
  by case/orP=> [/eqP->|//]; rewrite -aEb => aIs1; case/negP: aNIs1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
#|s1| <= size (b :: rm_rep b s2) 
have [bIs1|bNIs1]/= := boolP (b \in s1); last first.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bNIs1:b \notin s1
#|s1| <= (size (rm_rep b s2)).+1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1
#|s1| <= (size (rm_rep b s2)).+1
  apply: leq_trans (IH _ _ _ bNIs1) _ => //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bNIs1:b \notin s1
{subset s1 <= s2}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1
#|s1| <= (size (rm_rep b s2)).+1
  move=> i is1; have := is1; have := s1S _ is1; rewrite inE.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bNIs1:b \notin s1
i:A
is1:i \in s1
(i == b) || (i \in s2) -> i \in s1 -> i \in s2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1
#|s1| <= (size (rm_rep b s2)).+1
  by case/orP=> [/eqP->|//] => bIs1; case/negP: bNIs1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1
#|s1| <= (size (rm_rep b s2)).+1
rewrite (cardsD1 b) bIs1 ltnS.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A),
{subset s1 <= s2} ->
a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1
#|s1 :\ b| <= size (rm_rep b s2)
apply: IH => [i|].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1
i:A
i \in s1 :\ b -> i \in s2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1
b \notin s1 :\ b
  by rewrite !inE => /andP[iDb1 /s1S]; rewrite inE (negPf iDb1).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1
b \notin s1 :\ b
by rewrite !inE eqxx.
Qed.

Lemma last_rm_rep (A : eqType) (a : A) s : last a (rm_rep a s) = last a s.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A
last a (rm_rep a s) = last a s
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A
last a (rm_rep a s) = last a s
by elim: s a => //= b l IH a; case: (_ =P _) => /= [->|_]; apply: IH.
Qed.

Lemma cat_rm_rep (A : eqType) (a : A) s1 s2 : 
  rm_rep a (s1 ++ s2) = rm_rep a s1 ++ rm_rep (last a s1) s2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s1, s2:seq A
rm_rep a (s1 ++ s2) =
rm_rep a s1 ++ rm_rep (last a s1) s2
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s1, s2:seq A
rm_rep a (s1 ++ s2) =
rm_rep a s1 ++ rm_rep (last a s1) s2
elim: s1 s2 a => //= b s1 IH s2 a.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b:A
s1:seq A
IH:forall (s2 : seq A) (a : A),
rm_rep a (s1 ++ s2) =
rm_rep a s1 ++ rm_rep (last a s1) s2
s2:seq A
a:A
(if a == b
 then rm_rep b (s1 ++ s2)
 else b :: rm_rep b (s1 ++ s2)) =
(if a == b then rm_rep b s1 else b :: rm_rep b s1) ++
rm_rep (last b s1) s2
case: eqP => [aEb|aDb] /=; first by apply: IH.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b:A
s1:seq A
IH:forall (s2 : seq A) (a : A),
rm_rep a (s1 ++ s2) =
rm_rep a s1 ++ rm_rep (last a s1) s2
s2:seq A
a:A
aDb:a <> b
b :: rm_rep b (s1 ++ s2) =
b :: rm_rep b s1 ++ rm_rep (last b s1) s2
by congr (_ :: _); apply: IH.
Qed.

Lemma mem_rm_rep (A : eqType) (a b: A) s : 
   b != a -> b \in s -> b \in rm_rep a s.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a, b:A
s:seq_predType A
b != a -> b \in s -> b \in rm_rep a s
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a, b:A
s:seq_predType A
b != a -> b \in s -> b \in rm_rep a s
elim: s a => //= c s IH a bDa; rewrite inE.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b, c:A
s:seq A
IH:forall a : A,
b != a -> b \in s -> b \in rm_rep a s
a:A
bDa:b != a
(b == c) || (b \in s) ->
b \in (if a == c then rm_rep c s else c :: rm_rep c s)  
case: (boolP (b == c)) => /= [/eqP<- _|bDc bIs].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b, c:A
s:seq A
IH:forall a : A,
b != a -> b \in s -> b \in rm_rep a s
a:A
bDa:b != a
b \in (if a == b then rm_rep b s else b :: rm_rep b s)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b, c:A
s:seq A
IH:forall a : A,
b != a -> b \in s -> b \in rm_rep a s
a:A
bDa:b != a
bDc:b != c
bIs:b \in s
b \in (if a == c then rm_rep c s else c :: rm_rep c s)
  by rewrite eq_sym (negPf bDa) inE eqxx.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b, c:A
s:seq A
IH:forall a : A,
b != a -> b \in s -> b \in rm_rep a s
a:A
bDa:b != a
bDc:b != c
bIs:b \in s
b \in (if a == c then rm_rep c s else c :: rm_rep c s)
by have := IH _ bDc bIs; case: (_ == _); rewrite // inE orbC => ->.
Qed.

Lemma path_clshift m n (c : configuration (m + n)) cs :
    path move c cs ->
    path move (clshift c) (rm_rep (clshift c) [seq (clshift i) | i <- cs]).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
cs:seq (configuration (m + n))
path move c cs ->
path move (clshift c)
  (rm_rep (clshift c) [seq clshift i | i <- cs])
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
cs:seq (configuration (m + n))
path move c cs ->
path move (clshift c)
  (rm_rep (clshift c) [seq clshift i | i <- cs])
elim: cs c => //= c1 cs IH c => /andP[cMc1 c1Pcs].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
path move (clshift c)
  (rm_rep (clshift c) [seq clshift i | i <- cs])
c:configuration (m + n)
cMc1:move c c1
c1Pcs:path move c1 cs
path move (clshift c)
  (if clshift c == clshift c1
   then rm_rep (clshift c1) [seq clshift i | i <- cs]
   else
    clshift c1
    :: rm_rep (clshift c1) [seq clshift i | i <- cs])
case: eqP => [->|/eqP cDc1 /=]; first by apply: IH.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
path move (clshift c)
  (rm_rep (clshift c) [seq clshift i | i <- cs])
c:configuration (m + n)
cMc1:move c c1
c1Pcs:path move c1 cs
cDc1:clshift c != clshift c1
move (clshift c) (clshift c1) &&
path move (clshift c1)
  (rm_rep (clshift c1) [seq clshift i | i <- cs])
by rewrite move_clshift //=; apply: IH.
Qed.

Lemma path_crshift m n (c : configuration (m + n)) cs :
    path move c cs ->
    path move (crshift c) (rm_rep (crshift c) [seq (crshift i) | i <- cs]).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
cs:seq (configuration (m + n))
path move c cs ->
path move (crshift c)
  (rm_rep (crshift c) [seq crshift i | i <- cs])
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
cs:seq (configuration (m + n))
path move c cs ->
path move (crshift c)
  (rm_rep (crshift c) [seq crshift i | i <- cs])
elim: cs c => //= c1 cs IH c => /andP[cMc1 c1Pcs].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
path move (crshift c)
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
cMc1:move c c1
c1Pcs:path move c1 cs
path move (crshift c)
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
case: eqP => [->|/eqP cDc1 /=]; first by apply: IH.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
path move (crshift c)
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
cMc1:move c c1
c1Pcs:path move c1 cs
cDc1:crshift c != crshift c1
move (crshift c) (crshift c1) &&
path move (crshift c1)
  (rm_rep (crshift c1) [seq crshift i | i <- cs])
by rewrite move_crshift //=; apply: IH.
Qed.

Lemma path_shift  m n (c : configuration (m + n)) cs :
    path move c cs ->
    size cs = (size (rm_rep (clshift c) [seq (clshift i) | i <- cs]) +
               size(rm_rep (crshift c) [seq (crshift i) | i <- cs]))%nat.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
cs:seq (configuration (m + n))
path move c cs ->
size cs =
size (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size (rm_rep (crshift c) [seq crshift i | i <- cs])
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
cs:seq (configuration (m + n))
path move c cs ->
size cs =
size (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size (rm_rep (crshift c) [seq crshift i | i <- cs])
elim: cs c => //= c1 cs IH c /andP[/moveP[d [d2H d2H1 d2H2 d2H3]] c1Pcs].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
(size cs).+1 =
size
  (if clshift c == clshift c1
   then rm_rep (clshift c1) [seq clshift i | i <- cs]
   else
    clshift c1
    :: rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
case: (tsplitP d) => [j dE | k dE].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
(size cs).+1 =
size
  (if clshift c == clshift c1
   then rm_rep (clshift c1) [seq clshift i | i <- cs]
   else
    clshift c1
    :: rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
size
  (if clshift c == clshift c1
   then rm_rep (clshift c1) [seq clshift i | i <- cs]
   else
    clshift c1
    :: rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
  rewrite ifT; last first.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
clshift c == clshift c1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
(size cs).+1 =
size (rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
size
  (if clshift c == clshift c1
   then rm_rep (clshift c1) [seq clshift i | i <- cs]
   else
    clshift c1
    :: rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
    apply/eqP/ffunP=> i; rewrite !ffunE.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
i:ordinal_finType m
c (tlshift n i) = c1 (tlshift n i)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
(size cs).+1 =
size (rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
size
  (if clshift c == clshift c1
   then rm_rep (clshift c1) [seq clshift i | i <- cs]
   else
    clshift c1
    :: rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
    apply: d2H1; apply/eqP => /val_eqP /=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
i:ordinal_finType m
d == i + n -> False
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
(size cs).+1 =
size (rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
size
  (if clshift c == clshift c1
   then rm_rep (clshift c1) [seq clshift i | i <- cs]
   else
    clshift c1
    :: rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
    by rewrite dE eqn_leq andbC leqNgt (leq_trans (ltn_ord _)) ?leq_addl.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
(size cs).+1 =
size (rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
size
  (if clshift c == clshift c1
   then rm_rep (clshift c1) [seq clshift i | i <- cs]
   else
    clshift c1
    :: rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
  rewrite ifN /=; last first.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
crshift c != crshift c1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
(size cs).+1 =
size (rm_rep (clshift c1) [seq clshift i | i <- cs]) +
(size (rm_rep (crshift c1) [seq crshift i | i <- cs])).+1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
size
  (if clshift c == clshift c1
   then rm_rep (clshift c1) [seq clshift i | i <- cs]
   else
    clshift c1
    :: rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
    apply/eqP => /ffunP /(_ j); rewrite !ffunE => cE.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
cE:c (trshift m j) = c1 (trshift m j)
False
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
(size cs).+1 =
size (rm_rep (clshift c1) [seq clshift i | i <- cs]) +
(size (rm_rep (crshift c1) [seq crshift i | i <- cs])).+1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
size
  (if clshift c == clshift c1
   then rm_rep (clshift c1) [seq clshift i | i <- cs]
   else
    clshift c1
    :: rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
    move: d2H; rewrite (_ : c d = c1 d) ?(irH) //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
cE:c (trshift m j) = c1 (trshift m j)
c d = c1 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
(size cs).+1 =
size (rm_rep (clshift c1) [seq clshift i | i <- cs]) +
(size (rm_rep (crshift c1) [seq crshift i | i <- cs])).+1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
size
  (if clshift c == clshift c1
   then rm_rep (clshift c1) [seq clshift i | i <- cs]
   else
    clshift c1
    :: rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
    by rewrite (_ : d = (trshift m j)) //=; apply/val_eqP/eqP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
(size cs).+1 =
size (rm_rep (clshift c1) [seq clshift i | i <- cs]) +
(size (rm_rep (crshift c1) [seq crshift i | i <- cs])).+1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
size
  (if clshift c == clshift c1
   then rm_rep (clshift c1) [seq clshift i | i <- cs]
   else
    clshift c1
    :: rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
  rewrite addnS; congr _.+1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
size cs =
size (rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size (rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
size
  (if clshift c == clshift c1
   then rm_rep (clshift c1) [seq clshift i | i <- cs]
   else
    clshift c1
    :: rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
  by apply: IH.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
size
  (if clshift c == clshift c1
   then rm_rep (clshift c1) [seq clshift i | i <- cs]
   else
    clshift c1
    :: rm_rep (clshift c1) [seq clshift i | i <- cs]) +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
rewrite ifN /=; last first.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
clshift c != clshift c1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
(size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
  apply/eqP => /ffunP /(_ k); rewrite !ffunE => cE.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
cE:c (tlshift n k) = c1 (tlshift n k)
False
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
(size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
  move: d2H; rewrite (_ : c d = c1 d) ?(irH) //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
cE:c (tlshift n k) = c1 (tlshift n k)
c d = c1 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
(size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
  by rewrite (_ : d = (tlshift n k)) //=; apply/val_eqP/eqP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
(size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 +
size
  (if crshift c == crshift c1
   then rm_rep (crshift c1) [seq crshift i | i <- cs]
   else
    crshift c1
    :: rm_rep (crshift c1) [seq crshift i | i <- cs])
rewrite ifT; last first.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
crshift c == crshift c1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
(size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 +
size (rm_rep (crshift c1) [seq crshift i | i <- cs])
  apply/eqP/ffunP=> i; rewrite !ffunE.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
i:ordinal_finType n
c (trshift m i) = c1 (trshift m i)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
(size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 +
size (rm_rep (crshift c1) [seq crshift i | i <- cs])
  apply: d2H1; apply/eqP => /val_eqP /=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
i:ordinal_finType n
d == i -> False
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
(size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 +
size (rm_rep (crshift c1) [seq crshift i | i <- cs])
  by rewrite dE eqn_leq leqNgt (leq_trans (ltn_ord _)) ?leq_addl.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 =
(size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 +
size (rm_rep (crshift c1) [seq crshift i | i <- cs])
congr _.+1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n),
path move c cs ->
size cs =
size
  (rm_rep (clshift c) [seq clshift i | i <- cs]) +
size
  (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n),
d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
size cs =
(fix add (n m : nat) {struct n} : nat :=
   match n with
   | 0 => m
   | p.+1 => (add p m).+1
   end)
  (size
     (rm_rep (clshift c1) [seq clshift i | i <- cs]))
  (size
     (rm_rep (crshift c1) [seq crshift i | i <- cs]))
by apply: IH.
Qed.
    
Lemma gdist_clshift n m (c1 c2 : configuration (m + n)) : 
  connect move c1 c2 ->
  `d[clshift c1, clshift c2]_move <= `d[c1, c2]_move.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
connect move c1 c2 ->
`d[clshift c1, clshift c2]_move <= `d[c1, c2]_move
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
connect move c1 c2 ->
`d[clshift c1, clshift c2]_move <= `d[c1, c2]_move
move=> /gpath_connect[p pH].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
`d[clshift c1, clshift c2]_move <= `d[c1, c2]_move
have := size_rm_rep (clshift c1) [seq (clshift i) | i <- p].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
size (rm_rep (clshift c1) [seq clshift i | i <- p]) <=
size [seq clshift i | i <- p] ->
`d[clshift c1, clshift c2]_move <= `d[c1, c2]_move
rewrite (gpath_dist pH) size_map; move/(leq_trans _); apply.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
`d[clshift c1, clshift c2]_move <=
size (rm_rep (clshift c1) [seq clshift i | i <- p])
apply: gdist_path_le; first by apply/path_clshift/(gpath_path pH).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
last (clshift c1)
  (rm_rep (clshift c1) [seq clshift i | i <- p]) =
clshift c2
by rewrite last_rm_rep last_map (gpath_last pH).
Qed.

Lemma gdist_crshift n m (c1 c2 : configuration (m + n)) : 
  connect move c1 c2 ->
  `d[crshift c1, crshift c2]_move <= `d[c1, c2]_move.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
connect move c1 c2 ->
`d[crshift c1, crshift c2]_move <= `d[c1, c2]_move
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
connect move c1 c2 ->
`d[crshift c1, crshift c2]_move <= `d[c1, c2]_move
move=> /gpath_connect[p pH].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
`d[crshift c1, crshift c2]_move <= `d[c1, c2]_move
have := size_rm_rep (crshift c1) [seq (crshift i) | i <- p].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
size (rm_rep (crshift c1) [seq crshift i | i <- p]) <=
size [seq crshift i | i <- p] ->
`d[crshift c1, crshift c2]_move <= `d[c1, c2]_move
rewrite (gpath_dist pH) size_map; move/(leq_trans _); apply.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
`d[crshift c1, crshift c2]_move <=
size (rm_rep (crshift c1) [seq crshift i | i <- p])
apply: gdist_path_le; first by apply/path_crshift/(gpath_path pH).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
last (crshift c1)
  (rm_rep (crshift c1) [seq crshift i | i <- p]) =
crshift c2
by rewrite last_rm_rep last_map (gpath_last pH).
Qed.

Lemma gdist_cshift n m (c1 c2 : configuration (m + n)) : 
  connect move c1 c2 ->
  `d[clshift c1, clshift c2]_move + `d[crshift c1, crshift c2]_move 
       <= `d[c1, c2]_move.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
connect move c1 c2 ->
`d[clshift c1, clshift c2]_move +
`d[crshift c1, crshift c2]_move <= `d[c1, c2]_move
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
connect move c1 c2 ->
`d[clshift c1, clshift c2]_move +
`d[crshift c1, crshift c2]_move <= `d[c1, c2]_move
move=> /gpath_connect[p pH].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
`d[clshift c1, clshift c2]_move +
`d[crshift c1, crshift c2]_move <= `d[c1, c2]_move
rewrite (gpath_dist pH) (path_shift (gpath_path pH)).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
`d[clshift c1, clshift c2]_move +
`d[crshift c1, crshift c2]_move <=
size (rm_rep (clshift c1) [seq clshift i | i <- p]) +
size (rm_rep (crshift c1) [seq crshift i | i <- p])
apply: leq_add.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
`d[clshift c1, clshift c2]_move <=
size (rm_rep (clshift c1) [seq clshift i | i <- p])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
`d[crshift c1, crshift c2]_move <=
size (rm_rep (crshift c1) [seq crshift i | i <- p])
  apply: gdist_path_le; first by apply/path_clshift/(gpath_path pH).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
last (clshift c1)
  (rm_rep (clshift c1) [seq clshift i | i <- p]) =
clshift c2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
`d[crshift c1, crshift c2]_move <=
size (rm_rep (crshift c1) [seq crshift i | i <- p])
    by rewrite last_rm_rep last_map (gpath_last pH).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
`d[crshift c1, crshift c2]_move <=
size (rm_rep (crshift c1) [seq crshift i | i <- p])
apply: gdist_path_le; first by apply/path_crshift/(gpath_path pH).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq
  (finfun_finType (ordinal_finType (m + n))
     (ordinal_finType q))
pH:gpath move c1 c2 p
last (crshift c1)
  (rm_rep (crshift c1) [seq crshift i | i <- p]) =
crshift c2
by rewrite last_rm_rep last_map (gpath_last pH).
Qed.

Definition cliftrn m n p (c : configuration n) : configuration (m + n) :=
  cmerge `c[p] c.
Definition cliftr n : _ -> _ -> configuration n.+1 := @cliftrn 1 n.
Notation " ↑[ c ]_ p" := (cliftr p c) (at level 5, format "↑[ c ]_ p").

Definition cliftln m n p (c : configuration m) : configuration (m + n) :=
  cmerge c `c[p].

Definition cliftl n c p : configuration (n + 1) := (@cliftln n 1 c p).

Lemma cliftr_ldisk n p (c : configuration n) : ↑[c]_p ldisk = p.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c:configuration n
↑[c]_p ldisk = p
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c:configuration n
↑[c]_p ldisk = p 
rewrite ffunE; case: tsplitP => /= [j nE|t].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c:configuration n
j:'I_n
nE:n = j
c j = p
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c:configuration n
t:'I_1
n = t + n -> `c[p] t = p
  by have := ltn_ord j; rewrite {2}nE ltnn.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c:configuration n
t:'I_1
n = t + n -> `c[p] t = p
by rewrite ffunE.
Qed.

Lemma on_top_liftrn n m p x (c : configuration n) : 
  on_top (trshift m x) (cliftrn m p c) = on_top x c.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
x:'I_n
c:configuration n
on_top (trshift m x) (cliftrn m p c) = on_top x c
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
x:'I_n
c:configuration n
on_top (trshift m x) (cliftrn m p c) = on_top x c exact: on_top_merger. Qed.

Lemma move_liftrn n m p (c1 c2 : configuration n) :
    move (cliftrn m p c1) (cliftrn m p c2) = move c1 c2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c1, c2:configuration n
move (cliftrn m p c1) (cliftrn m p c2) = move c1 c2
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c1, c2:configuration n
move (cliftrn m p c1) (cliftrn m p c2) = move c1 c2 exact: move_merger. Qed.

Lemma path_liftrn n m p (c : configuration n) (cs : seq (configuration _)) :
    path move (cliftrn m p c) (map (cliftrn m p) cs) = 
    path move c cs.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c:configuration n
cs:seq (configuration n)
path move (cliftrn m p c)
  [seq cliftrn m p i | i <- cs] = path move c cs
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c:configuration n
cs:seq (configuration n)
path move (cliftrn m p c)
  [seq cliftrn m p i | i <- cs] = path move c cs exact: path_merger. Qed.

Lemma connect_liftrn n m p (c1 c2 : configuration n) : 
  connect move c1 c2 -> connect move (cliftrn m p c1) (cliftrn m p c2).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c1, c2:configuration n
connect move c1 c2 ->
connect move (cliftrn m p c1) (cliftrn m p c2)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c1, c2:configuration n
connect move c1 c2 ->
connect move (cliftrn m p c1) (cliftrn m p c2) exact: connect_merger. Qed.

Lemma gdist_liftrn n m p (c1 c2 : configuration n) : 
  connect move c1 c2 ->
  `d[cliftrn m p c1, cliftrn m p c2]_move <= `d[c1, c2]_move.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c1, c2:configuration n
connect move c1 c2 ->
`d[cliftrn m p c1, cliftrn m p c2]_move <=
`d[c1, c2]_move
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c1, c2:configuration n
connect move c1 c2 ->
`d[cliftrn m p c1, cliftrn m p c2]_move <=
`d[c1, c2]_move exact: gdist_merger. Qed.

Lemma move_liftr n p (c1 c2 : configuration n) :
  move ↑[c1]_p ↑[c2]_p = move c1 c2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c1, c2:configuration n
move ↑[c1]_p ↑[c2]_p = move c1 c2
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c1, c2:configuration n
move ↑[c1]_p ↑[c2]_p = move c1 c2 by exact: move_liftrn 1 p c1 c2. Qed.

Lemma perfect_liftr n p : ↑[`c[p]]_p = `c[p] :> configuration n.+1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
↑[`c[p]]_p = `c[p]
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
↑[`c[p]]_p = `c[p]
apply/ffunP => i; rewrite !ffunE.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
i:ordinal_finType n.+1
match tsplit i with
| inl j => `c[p] j
| inr j => `c[p] j
end = p
by case: tsplitP => [j|k]; rewrite !ffunE.
Qed.

Definition cunliftr {n} (c : configuration n.+1) : configuration n :=
  @crshift 1 n c.

Notation " ↓[ c ]" := (cunliftr c) (at level 5, format "↓[ c ]").

Lemma cliftrK n p : cancel (cliftr p) (cunliftr : _ -> configuration n).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
cancel (cliftr p)
  (cunliftr : configuration n.+1 -> configuration n)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
cancel (cliftr p)
  (cunliftr : configuration n.+1 -> configuration n) by move=> c; apply/ffunP => i; rewrite !ffunE tsplit_trshift. Qed.

Lemma cunliftrK n (c : configuration n.+1) : ↑[↓[c]]_(c ldisk) = c.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
↑[↓[c]]_(c ldisk) = c
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
↑[↓[c]]_(c ldisk) = c
apply/ffunP => i; rewrite !ffunE.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
i:ordinal_finType n.+1
match tsplit i with
| inl j => `c[c ldisk] j
| inr j => ↓[c] j
end = c i
case: tsplitP => [] j iE; rewrite !ffunE; congr fun_of_fin;
  apply/val_eqP/eqP => //=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
i:ordinal_finType n.+1
j:'I_1
iE:i = j + n
n = i
by rewrite iE; case: (j) => [] [].
Qed.

Lemma cliftr_inj n p : injective (@cliftr n p).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
injective (cliftr p)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
injective (cliftr p) by move=> c1 c2 c1Ec2; rewrite -[c1](cliftrK p) c1Ec2 cliftrK. Qed.

Lemma map_eqr (T1 T2 : eqType) (f : T1 -> T2) (s1 s2 : seq T1) :
   injective f ->
   ([seq f i | i <- s1] == [seq f i | i <- s2]) = (s1 == s2).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
T1, T2:eqType
f:T1 -> T2
s1, s2:seq T1
injective f ->
([seq f i | i <- s1] == [seq f i | i <- s2]) =
(s1 == s2)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
T1, T2:eqType
f:T1 -> T2
s1, s2:seq T1
injective f ->
([seq f i | i <- s1] == [seq f i | i <- s2]) =
(s1 == s2)
elim: s1 s2 => [[|] //|a s1 IH [|b s2]//=] fInj.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
T1, T2:eqType
f:T1 -> T2
a:T1
s1:seq T1
IH:forall s2 : seq T1,
injective f ->
([seq f i | i <- s1] == [seq f i | i <- s2]) =
(s1 == s2)
b:T1
s2:seq T1
fInj:injective f
(f a :: [seq f i | i <- s1] ==
 f b :: [seq f i | i <- s2]) = (a :: s1 == b :: s2)
rewrite !eqseq_cons IH //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
T1, T2:eqType
f:T1 -> T2
a:T1
s1:seq T1
IH:forall s2 : seq T1,
injective f ->
([seq f i | i <- s1] == [seq f i | i <- s2]) =
(s1 == s2)
b:T1
s2:seq T1
fInj:injective f
(f a == f b) && (s1 == s2) = (a == b) && (s1 == s2)
case: (a =P b) => [->//|]; first by rewrite eqxx.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
T1, T2:eqType
f:T1 -> T2
a:T1
s1:seq T1
IH:forall s2 : seq T1,
injective f ->
([seq f i | i <- s1] == [seq f i | i <- s2]) =
(s1 == s2)
b:T1
s2:seq T1
fInj:injective f
a <> b ->
(f a == f b) && (s1 == s2) = false && (s1 == s2)
by case: (f a =P f b) => [/fInj|//].
Qed.

Lemma eq_map_liftr n p (cs1 cs2 : seq (configuration n)) :
 ([seq ↑[i]_p | i <- cs1] == [seq ↑[i]_p | i <- cs2]) = (cs1 == cs2).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
cs1, cs2:seq (configuration n)
([seq ↑[i]_p | i <- cs1] == [seq ↑[i]_p | i <- cs2]) =
(cs1 == cs2)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
cs1, cs2:seq (configuration n)
([seq ↑[i]_p | i <- cs1] == [seq ↑[i]_p | i <- cs2]) =
(cs1 == cs2) by apply/map_eqr/cliftr_inj. Qed.

Lemma perfect_unliftr n p : ↓[`c[p]] = `c[p] :> configuration n.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
↓[`c[p]] = `c[p]
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
↓[`c[p]] = `c[p] by apply/ffunP => i; rewrite !ffunE. Qed.

Lemma s2f_liftr n (c : configuration n.+1) (p : peg) :
  s2f ([set i | c i == p] :\ ord_max) = s2f [set i | cunliftr c i == p].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
s2f ([set i | c i == p] :\ ord_max) =
s2f [set i | ↓[c] i == p]
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
s2f ([set i | c i == p] :\ ord_max) =
s2f [set i | ↓[c] i == p]
apply/fsetP=> i.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
(i \in s2f ([set i | c i == p] :\ ord_max)) =
(i \in s2f [set i | ↓[c] i == p])
apply/imfsetP/imfsetP => [] [/= j].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1
j \in [set i | c i == p] :\ ord_max ->
i = j ->
exists2 x : 'I_n, x \in [set i | ↓[c] i == p] & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n
j \in [set i | ↓[c] i == p] ->
i = j ->
exists2 x : 'I_n.+1,
  x \in [set i | c i == p] :\ ord_max & i = x
  rewrite !inE => /andP[jDn /eqP cjEp] jEi.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1
jDn:j != ord_max
cjEp:c j = p
jEi:i = j
exists2 x : 'I_n, x \in [set i | ↓[c] i == p] & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n
j \in [set i | ↓[c] i == p] ->
i = j ->
exists2 x : 'I_n.+1,
  x \in [set i | c i == p] :\ ord_max & i = x
  have jLn : j < n.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1
jDn:j != ord_max
cjEp:c j = p
jEi:i = j
j < n
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1
jDn:j != ord_max
cjEp:c j = p
jEi:i = j
jLn:j < n
exists2 x : 'I_n, x \in [set i | ↓[c] i == p] & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n
j \in [set i | ↓[c] i == p] ->
i = j ->
exists2 x : 'I_n.+1,
  x \in [set i | c i == p] :\ ord_max & i = x
    rewrite -val_eqE /= in jDn.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1
cjEp:c j = p
jEi:i = j
jDn:j != n
j < n
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1
jDn:j != ord_max
cjEp:c j = p
jEi:i = j
jLn:j < n
exists2 x : 'I_n, x \in [set i | ↓[c] i == p] & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n
j \in [set i | ↓[c] i == p] ->
i = j ->
exists2 x : 'I_n.+1,
  x \in [set i | c i == p] :\ ord_max & i = x
    by have := ltn_ord j; rewrite ltnS leq_eqVlt (negPf jDn).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1
jDn:j != ord_max
cjEp:c j = p
jEi:i = j
jLn:j < n
exists2 x : 'I_n, x \in [set i | ↓[c] i == p] & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n
j \in [set i | ↓[c] i == p] ->
i = j ->
exists2 x : 'I_n.+1,
  x \in [set i | c i == p] :\ ord_max & i = x
  exists (Ordinal jLn) => //=; rewrite !inE ffunE; apply/eqP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1
jDn:j != ord_max
cjEp:c j = p
jEi:i = j
jLn:j < n
c (trshift 1 (Ordinal jLn)) = p
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n
j \in [set i | ↓[c] i == p] ->
i = j ->
exists2 x : 'I_n.+1,
  x \in [set i | c i == p] :\ ord_max & i = x
  by rewrite -cjEp; congr (c _); apply: val_eqP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n
j \in [set i | ↓[c] i == p] ->
i = j ->
exists2 x : 'I_n.+1,
  x \in [set i | c i == p] :\ ord_max & i = x
rewrite inE ffunE => /eqP cjEp iEj; exists (trshift 1 j) => //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n
cjEp:c (trshift 1 j) = p
iEj:i = j
trshift 1 j \in [set i | c i == p] :\ ord_max
by rewrite !inE cjEp -val_eqE //= neq_ltn ltn_ord /=.
Qed.

Lemma codom_liftr n (c : configuration n.+1) (s : seq peg) :
  codom c \subset s -> codom ↓[c] \subset s.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
s:seq peg
codom c \subset s -> codom ↓[c] \subset s
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
s:seq peg
codom c \subset s -> codom ↓[c] \subset s
move=> H; apply/subsetP => i /mapP[j _ ->].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
s:seq peg
H:codom c \subset s
i:ordinal_finType q
j:ordinal_finType n
↓[c] j \in s
by rewrite ffunE; apply: (subsetP H); apply: codom_f.
Qed.

Lemma move_ldisk n (c1 c2 : configuration n.+1) : 
  move c1 c2 -> c1 ldisk != c2 ldisk -> ↓[c1] = ↓[c2].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
move c1 c2 -> c1 ldisk != c2 ldisk -> ↓[c1] = ↓[c2]
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
move c1 c2 -> c1 ldisk != c2 ldisk -> ↓[c1] = ↓[c2]
move=> c1Mc2 c10Dc20.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
c1Mc2:move c1 c2
c10Dc20:c1 ldisk != c2 ldisk
↓[c1] = ↓[c2]
apply/ffunP=> i; rewrite !ffunE /=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
c1Mc2:move c1 c2
c10Dc20:c1 ldisk != c2 ldisk
i:ordinal_finType n
c1 (trshift 1 i) = c2 (trshift 1 i)
apply: move_disk1 c1Mc2 c10Dc20 _.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
i:ordinal_finType n
ldisk != trshift 1 i
apply/eqP/val_eqP => /=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
i:ordinal_finType n
n != i
by rewrite eqn_leq negb_and -ltnNge ltn_ord.
Qed.

Lemma move_unliftr n (c1 c2 : configuration n.+1) :
  c1 ldisk = c2 ldisk -> move ↓[c1] ↓[c2] = move c1 c2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
c1 ldisk = c2 ldisk -> move ↓[c1] ↓[c2] = move c1 c2
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
c1 ldisk = c2 ldisk -> move ↓[c1] ↓[c2] = move c1 c2
by move=> c1lEc2l; rewrite -(@move_liftr _ (c1 ldisk)) {2}c1lEc2l !cunliftrK.
Qed.

Lemma path_move_rev (n : nat) (c : configuration n) cs : 
  path move (last c cs) (rev (belast c cs)) = path move c cs.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n
cs:seq (configuration n)
path move (last c cs) (rev (belast c cs)) =
path move c cs
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n
cs:seq (configuration n)
path move (last c cs) (rev (belast c cs)) =
path move c cs
by rewrite rev_path; apply: eq_path => c1 c2; exact: move_sym. 
Qed.

Lemma path_liftr n p (c : configuration n) (cs : seq (configuration _)) :
  path move ↑[c]_p [seq ↑[i]_p | i <- cs] = path move c cs.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c:configuration n
cs:seq (configuration n)
path move ↑[c]_p [seq ↑[i]_p | i <- cs] =
path move c cs
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c:configuration n
cs:seq (configuration n)
path move ↑[c]_p [seq ↑[i]_p | i <- cs] =
path move c cs by apply: (@path_merger 1). Qed.

Lemma connect_liftr n p (c1 c2 : configuration n) : 
  connect move c1 c2 -> connect move ↑[c1]_p ↑[c2]_p.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c1, c2:configuration n
connect move c1 c2 -> connect move ↑[c1]_p ↑[c2]_p
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c1, c2:configuration n
connect move c1 c2 -> connect move ↑[c1]_p ↑[c2]_p by apply: (@connect_merger 1). Qed.

Lemma gdist_liftr n p (c1 c2 : configuration n) : 
  connect move c1 c2 ->  `d[↑[c1]_p, ↑[c2]_p]_move <= `d[c1, c2]_move .
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c1, c2:configuration n
connect move c1 c2 ->
`d[↑[c1]_p, ↑[c2]_p]_move <= `d[c1, c2]_move
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c1, c2:configuration n
connect move c1 c2 ->
`d[↑[c1]_p, ↑[c2]_p]_move <= `d[c1, c2]_move by apply: (@gdist_merger 1). Qed.

Lemma path_unlift_eq n (c : configuration n.+1) (cs : seq (configuration _)) :
   (forall c1, c1 \in cs -> c1 ldisk = c ldisk)-> 
    path move ↓[c] [seq ↓[i] | i <- cs] = path move c cs.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
(forall
   c1 : finfun_eqType (ordinal_finType n.+1)
          (ordinal_eqType q),
 c1 \in cs -> c1 ldisk = c ldisk) ->
path move ↓[c] [seq ↓[i] | i <- cs] = path move c cs
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
(forall
   c1 : finfun_eqType (ordinal_finType n.+1)
          (ordinal_eqType q),
 c1 \in cs -> c1 ldisk = c ldisk) ->
path move ↓[c] [seq ↓[i] | i <- cs] = path move c cs
move=> H.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
H:forall
  c1 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c1 \in cs -> c1 ldisk = c ldisk
path move ↓[c] [seq ↓[i] | i <- cs] = path move c cs
rewrite -(@path_liftr _  (c ldisk)).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
H:forall
  c1 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c1 \in cs -> c1 ldisk = c ldisk
path move ↑[↓[c]]_(c ldisk)
  [seq ↑[i]_(c ldisk) | i <- [seq ↓[i] | i <- cs]] =
path move c cs
rewrite cunliftrK -map_comp.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
H:forall
  c1 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c1 \in cs -> c1 ldisk = c ldisk
path move c
  [seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i
     | i <- cs] = path move c cs
congr path.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
H:forall
  c1 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c1 \in cs -> c1 ldisk = c ldisk
[seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i
   | i <- cs] = cs
elim: cs H => //= a cs IH H.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c, a:configuration n.+1
cs:seq (configuration n.+1)
IH:(forall c1 : {ffun 'I_n.+1 -> 'I_q},
 c1 \in cs -> c1 ldisk = c ldisk) ->
[seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i
   | i <- cs] = cs
H:forall c1 : {ffun 'I_n.+1 -> 'I_q},
c1 \in a :: cs -> c1 ldisk = c ldisk
↑[↓[a]]_(c ldisk)
:: [seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i
      | i <- cs] = a :: cs
rewrite -{1}(H a).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c, a:configuration n.+1
cs:seq (configuration n.+1)
IH:(forall c1 : {ffun 'I_n.+1 -> 'I_q},
 c1 \in cs -> c1 ldisk = c ldisk) ->
[seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i
   | i <- cs] = cs
H:forall c1 : {ffun 'I_n.+1 -> 'I_q},
c1 \in a :: cs -> c1 ldisk = c ldisk
↑[↓[a]]_(a ldisk)
:: [seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i
      | i <- cs] = a :: cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c, a:configuration n.+1
cs:seq (configuration n.+1)
IH:(forall c1 : {ffun 'I_n.+1 -> 'I_q},
 c1 \in cs -> c1 ldisk = c ldisk) ->
[seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i
   | i <- cs] = cs
H:forall c1 : {ffun 'I_n.+1 -> 'I_q},
c1 \in a :: cs -> c1 ldisk = c ldisk
a \in a :: cs
  by rewrite cunliftrK IH // => v Hv; apply: H; rewrite inE orbC Hv.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c, a:configuration n.+1
cs:seq (configuration n.+1)
IH:(forall c1 : {ffun 'I_n.+1 -> 'I_q},
 c1 \in cs -> c1 ldisk = c ldisk) ->
[seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i
   | i <- cs] = cs
H:forall c1 : {ffun 'I_n.+1 -> 'I_q},
c1 \in a :: cs -> c1 ldisk = c ldisk
a \in a :: cs
by rewrite inE eqxx.
Qed.

Lemma path_unlift n (c : configuration n.+1) (cs : seq (configuration _)) :
  path move c cs ->
  path move ↓[c] (rm_rep ↓[c] [seq ↓[i] | i <- cs]).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
path move c cs ->
path move ↓[c] (rm_rep ↓[c] [seq ↓[i] | i <- cs])
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
path move c cs ->
path move ↓[c] (rm_rep ↓[c] [seq ↓[i] | i <- cs]) by move=> H; apply: path_crshift. Qed.

Lemma gdist_cunlift n (c1 c2 : configuration n.+1) : 
  connect move c1 c2 -> `d[↓[c1], ↓[c2]]_move <= `d[c1, c2]_move.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
connect move c1 c2 ->
`d[↓[c1], ↓[c2]]_move <= `d[c1, c2]_move
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
connect move c1 c2 ->
`d[↓[c1], ↓[c2]]_move <= `d[c1, c2]_move by move=> H; apply: gdist_crshift. Qed.

Lemma gdist_cunlift_eq n (c1 c2 : configuration n.+1) : 
  irreflexive r ->
  connect move c1 c2 ->  c1 ldisk = c2 ldisk ->
    `d[c1, c2]_move = `d[↓[c1], ↓[c2]]_move.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
irreflexive r ->
connect move c1 c2 ->
c1 ldisk = c2 ldisk ->
`d[c1, c2]_move = `d[↓[c1], ↓[c2]]_move
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
irreflexive r ->
connect move c1 c2 ->
c1 ldisk = c2 ldisk ->
`d[c1, c2]_move = `d[↓[c1], ↓[c2]]_move
move=> ir c1Cc2 c1Ec2; apply/eqP; rewrite eqn_leq gdist_cunlift // andbT.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
ir:irreflexive r
c1Cc2:connect move c1 c2
c1Ec2:c1 ldisk = c2 ldisk
`d[c1, c2]_move <= `d[↓[c1], ↓[c2]]_move
rewrite -{1}[c1]cunliftrK -{1}[c2]cunliftrK -c1Ec2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
ir:irreflexive r
c1Cc2:connect move c1 c2
c1Ec2:c1 ldisk = c2 ldisk
`d[↑[↓[c1]]_(c1 ldisk), ↑[↓[c2]]_(c1 ldisk)]_move <=
`d[↓[c1], ↓[c2]]_move
apply: gdist_liftr => //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
ir:irreflexive r
c1Cc2:connect move c1 c2
c1Ec2:c1 ldisk = c2 ldisk
connect move ↓[c1] ↓[c2]
case/connectP: c1Cc2 => p pH c2E.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
ir:irreflexive r
c1Ec2:c1 ldisk = c2 ldisk
p:seq
  (finfun_finType (ordinal_finType n.+1)
     (ordinal_finType q))
pH:path move c1 p
c2E:c2 = last c1 p
connect move ↓[c1] ↓[c2]
apply/connectP; exists (rm_rep (↓[c1]) ([seq ↓[i] | i <- p])) => //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
ir:irreflexive r
c1Ec2:c1 ldisk = c2 ldisk
p:seq
  (finfun_finType (ordinal_finType n.+1)
     (ordinal_finType q))
pH:path move c1 p
c2E:c2 = last c1 p
path move ↓[c1] (rm_rep ↓[c1] [seq ↓[i] | i <- p])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
ir:irreflexive r
c1Ec2:c1 ldisk = c2 ldisk
p:seq
  (finfun_finType (ordinal_finType n.+1)
     (ordinal_finType q))
pH:path move c1 p
c2E:c2 = last c1 p
↓[c2] = last ↓[c1] (rm_rep ↓[c1] [seq ↓[i] | i <- p])
  by apply: path_unlift.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
ir:irreflexive r
c1Ec2:c1 ldisk = c2 ldisk
p:seq
  (finfun_finType (ordinal_finType n.+1)
     (ordinal_finType q))
pH:path move c1 p
c2E:c2 = last c1 p
↓[c2] = last ↓[c1] (rm_rep ↓[c1] [seq ↓[i] | i <- p])
by rewrite last_rm_rep c2E last_map.
Qed.

Lemma perfect_liftrn m n p : 
  cliftrn m p (`c[p]) = `c[p] :> configuration (m + n).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
p:peg
cliftrn m p `c[p] = `c[p]
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
p:peg
cliftrn m p `c[p] = `c[p]
by apply/ffunP => i; rewrite !ffunE; case: tsplitP => j; rewrite !ffunE.
Qed.

(* case distinction that depends if the largest disk has move                 *)
(*  if it has not moved, we get the path on the unlifted configuration        *)
(*  uf it has moved, we get the decomposition till the first move             *)
Inductive pathS_spec (n : nat)  (c : configuration n.+1) 
                                (cs : seq (configuration n.+1)) :
   forall (b : bool), Type
  :=
  pathS_specW : 
    forall (p := c ldisk) (c1 := ↓[c]) (cs1 := [seq ↓[i] | i <- cs]),
      cs = [seq ↑[i]_p | i <- cs1] -> path move c1 cs1 -> pathS_spec c cs true |
  pathS_spec_move : 
    forall (p1 := c ldisk) p2 cs1 cs2
           (c1 := ↓[c])
           (c2 := ↑[last c1 cs1]_p2),
        p1 != p2 -> r p1 p2 -> 
        cs = [seq ↑[i]_p1 | i <- cs1] ++ c2 :: cs2 ->
        path move c1 cs1 -> move ↑[last c1 cs1]_p1 c2 ->
        path move c2 cs2 ->
        pathS_spec c cs true |
  pathS_spec_false : pathS_spec c cs false.

(* Inversion theorem on a path for disk n.+1 *)
Lemma pathSP  n (c : configuration n.+1) cs : pathS_spec c cs (path move c cs).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
pathS_spec c cs (path move c cs)
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
pathS_spec c cs (path move c cs)
have [Hp|_] := boolP (path _ _ _); last by apply: pathS_spec_false.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
pathS_spec c cs true
pose f (c1 : configuration n.+1) := c1 ldisk != c ldisk.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
pathS_spec c cs true
have [Hh|/hasPn Hn] := boolP (has f cs); last first.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs,
  forall
    x : finfun_eqType (ordinal_finType n.+1)
          (ordinal_eqType q), 
  ~~ f x}
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
pathS_spec c cs true
  have csE : cs = [seq ↑[i]_(c ldisk) | i <- [seq ↓[i] | i <- cs]].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs,
  forall
    x : finfun_eqType (ordinal_finType n.+1)
          (ordinal_eqType q), 
  ~~ f x}
cs = [seq ↑[i]_(c ldisk) | i <- [seq ↓[i] | i <- cs]]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs,
  forall
    x : finfun_eqType (ordinal_finType n.+1)
          (ordinal_eqType q), 
  ~~ f x}
csE:cs =
[seq ↑[i]_(c ldisk) | i <- [seq ↓[i] | i <- cs]]
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
pathS_spec c cs true
    rewrite -map_comp -[LHS]map_id.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs,
  forall
    x : finfun_eqType (ordinal_finType n.+1)
          (ordinal_eqType q), 
  ~~ f x}
[seq x | x <- cs] =
[seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i
   | i <- cs]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs,
  forall
    x : finfun_eqType (ordinal_finType n.+1)
          (ordinal_eqType q), 
  ~~ f x}
csE:cs =
[seq ↑[i]_(c ldisk) | i <- [seq ↓[i] | i <- cs]]
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
pathS_spec c cs true
    apply/eq_in_map => x /Hn; rewrite negbK => /eqP <-/=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs,
  forall
    x : finfun_eqType (ordinal_finType n.+1)
          (ordinal_eqType q), 
  ~~ f x}
x:finfun_eqType (ordinal_finType n.+1)
  (ordinal_eqType q)
x = ↑[↓[x]]_(x ldisk)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs,
  forall
    x : finfun_eqType (ordinal_finType n.+1)
          (ordinal_eqType q), 
  ~~ f x}
csE:cs =
[seq ↑[i]_(c ldisk) | i <- [seq ↓[i] | i <- cs]]
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
pathS_spec c cs true
    by rewrite cunliftrK.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs,
  forall
    x : finfun_eqType (ordinal_finType n.+1)
          (ordinal_eqType q), 
  ~~ f x}
csE:cs =
[seq ↑[i]_(c ldisk) | i <- [seq ↓[i] | i <- cs]]
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
pathS_spec c cs true
  apply: pathS_specW csE _.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs,
  forall
    x : finfun_eqType (ordinal_finType n.+1)
          (ordinal_eqType q), 
  ~~ f x}
path move ↓[c] [seq ↓[i] | i <- cs]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
pathS_spec c cs true
  by rewrite path_unlift_eq // => c1 /Hn; rewrite negbK => /eqP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
pathS_spec c cs true
pose n1 := find f cs; pose lc1 := nth c cs n1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
pathS_spec c cs true
pose p1 := c ldisk; pose p2 := lc1 ldisk.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
pathS_spec c cs true
have p1Dp2 : p1 != p2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1 != p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
pathS_spec c cs true
  by have := nth_find c Hh; rewrite eq_sym.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
pathS_spec c cs true
pose c1 :=  ↓[c].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
pathS_spec c cs true
pose lcs1 := take n1 cs; pose cs2 := drop n1.+1 cs.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
pathS_spec c cs true
have slcs1 : size lcs1 = n1 by rewrite size_take -has_find Hh.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
pathS_spec c cs true
have Plcs1 c2 : c2 \in lcs1 -> c2 ldisk = p1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
c2:finfun_eqType (ordinal_finType n.+1)
  (ordinal_eqType q)
c2 \in lcs1 -> c2 ldisk = p1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
pathS_spec c cs true
  move=> c2Ilcs1p; move: (c2Ilcs1p).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
c2:finfun_eqType (ordinal_finType n.+1)
  (ordinal_eqType q)
c2Ilcs1p:c2 \in lcs1
c2 \in lcs1 -> c2 ldisk = p1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
pathS_spec c cs true
  rewrite -index_mem slcs1 => /(before_find c) /idP /negP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
c2:finfun_eqType (ordinal_finType n.+1)
  (ordinal_eqType q)
c2Ilcs1p:c2 \in lcs1
~~ f (nth c cs (index c2 lcs1)) -> c2 ldisk = p1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
pathS_spec c cs true
  rewrite negbK => /eqP.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
c2:finfun_eqType (ordinal_finType n.+1)
  (ordinal_eqType q)
c2Ilcs1p:c2 \in lcs1
nth c cs (index c2 lcs1) ldisk = c ldisk ->
c2 ldisk = p1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
pathS_spec c cs true
  by rewrite -[cs](cat_take_drop n1) nth_cat index_mem c2Ilcs1p nth_index.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
pathS_spec c cs true
pose cs1 := map cunliftr lcs1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
pathS_spec c cs true
have lcs1E : lcs1 = [seq ↑[i]_p1 | i <- cs1].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1 = [seq ↑[i]_p1 | i <- cs1]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
pathS_spec c cs true
  rewrite -map_comp -[LHS]map_id.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
[seq x | x <- lcs1] =
[seq ([eta cliftr p1] \o cunliftr) i | i <- lcs1]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
pathS_spec c cs true
  apply/eq_in_map => x /Plcs1 H.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
x:finfun_eqType (ordinal_finType n.+1)
  (ordinal_eqType q)
H:x ldisk = p1
x = ([eta cliftr p1] \o cunliftr) x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
pathS_spec c cs true
  by rewrite /= -H cunliftrK.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
pathS_spec c cs true
have csE : cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
pathS_spec c cs true
  by rewrite -[cs](cat_take_drop n1.+1)  -cat_rcons -lcs1E 
             (take_nth c) // -has_find.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
pathS_spec c cs true
have Hm : move (last c lcs1) lc1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
move (last c lcs1) lc1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
pathS_spec c cs true
 by move: Hp; rewrite csE lcs1E cat_path /= => /and3P[].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
pathS_spec c cs true
have lc1E : lc1 = cliftr p2 (last c1 cs1).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1 = ↑[last c1 cs1]_p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
  rewrite /p2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1 = ↑[last c1 cs1]_(lc1 ldisk)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
  have Hd : (last c lcs1) ldisk != lc1 ldisk.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
last c lcs1 ldisk != lc1 ldisk
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk
lc1 = ↑[last c1 cs1]_(lc1 ldisk)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
    case: (lcs1) Plcs1 => //= a l -> //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
a:configuration n.+1
l:seq (configuration n.+1)
last a l \in a :: l
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk
lc1 = ↑[last c1 cs1]_(lc1 ldisk)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
    by apply: mem_last.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk
lc1 = ↑[last c1 cs1]_(lc1 ldisk)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
  rewrite last_map -[LHS]cunliftrK.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk
↑[↓[lc1]]_(lc1 ldisk) = ↑[↓[last c lcs1]]_(lc1 ldisk)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
  congr cliftr.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk
↓[lc1] = ↓[last c lcs1]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
  apply/ffunP=> i; rewrite !ffunE /=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk
i:ordinal_finType n
lc1 (trshift 1 i) = last c lcs1 (trshift 1 i)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
  apply/sym_equal/(move_disk1 Hm Hd).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk
i:ordinal_finType n
ldisk != trshift 1 i
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
  apply/eqP/val_eqP => /=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk
i:ordinal_finType n
n != i
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
  by rewrite eqn_leq negb_and -ltnNge ltn_ord.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
have Hm1 : move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
pathS_spec c cs true
  have ->: ↑[last ↓[c] cs1]_p1 = last c lcs1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
↑[last ↓[c] cs1]_p1 = last c lcs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
move (last c lcs1) ↑[last c1 cs1]_p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
pathS_spec c cs true
    by rewrite -[in LHS]last_map -lcs1E cunliftrK.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
move (last c lcs1) ↑[last c1 cs1]_p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
pathS_spec c cs true
  by rewrite -lc1E.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
pathS_spec c cs true
apply: pathS_spec_move (p1Dp2) _ _ _ (Hm1) _ => //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
r (c ldisk) p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
cs =
[seq ↑[i]_(c ldisk) | i <- cs1] ++
↑[last ↓[c] cs1]_p2 :: ?Goal
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↓[c] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 ?Goal
-
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
r (c ldisk) p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
cs =
[seq ↑[i]_(c ldisk) | i <- cs1] ++
↑[last ↓[c] cs1]_p2 :: ?Goal
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↓[c] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 ?Goal  have := @move_diskr _ ldisk _ _ Hm1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
(↑[last c1 cs1]_p1 ldisk != ↑[last c1 cs1]_p2 ldisk ->
 r (↑[last c1 cs1]_p1 ldisk) (↑[last c1 cs1]_p2 ldisk)) ->
r (c ldisk) p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
cs =
[seq ↑[i]_(c ldisk) | i <- cs1] ++
↑[last ↓[c] cs1]_p2 :: ?Goal
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↓[c] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 ?Goal
   by rewrite !cliftr_ldisk; apply.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
cs =
[seq ↑[i]_(c ldisk) | i <- cs1] ++
↑[last ↓[c] cs1]_p2 :: ?Goal
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↓[c] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 ?Goal
-
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
cs =
[seq ↑[i]_(c ldisk) | i <- cs1] ++
↑[last ↓[c] cs1]_p2 :: ?Goal
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↓[c] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 ?Goal by rewrite csE lc1E lcs1E.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↓[c] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 cs2
-
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↓[c] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 cs2 rewrite path_unlift_eq => //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move c lcs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 cs2
  by move: Hp; rewrite -[cs](cat_take_drop n1) cat_path => /andP[].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 cs2
rewrite -lc1E.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall
  c2 : finfun_eqType (ordinal_finType n.+1)
         (ordinal_eqType q),
c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move lc1 cs2
by move: Hp; rewrite csE cat_path /= => /and3P[].
Qed.

(* we can restrict a path from n.+1 to n by removing all the moves of the     *)
(* largest disk                                                               *)
Lemma pathS_restrict n (c : configuration n.+1) cs :
   path move c cs -> 
   {cs'|
    [/\ path move ↓[c] cs',
        last ↓[c] cs' = ↓[last c cs] &
        size cs' <= size cs ?= 
          iff (cs ==  [seq ↑[i]_(c ldisk) | i <- cs'])]}.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
path move c cs ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs]
    & size cs' <= size cs
               ?= iff (cs ==
                       [seq ↑[i]_(c ldisk) | i <- cs'])]}
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
path move c cs ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs]
    & size cs' <= size cs
               ?= iff (cs ==
                       [seq ↑[i]_(c ldisk) | i <- cs'])]}
elim: cs c => /= [c _|c1 cs IH c /andP[cMc1 /IH[cs1 [c1Pcs1 lccs1Mlc1cs S]]]].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[c]
    & size cs' <= 0
               ?= iff ([::] ==
                       [seq ↑[i]_(c ldisk) | i <- cs'])]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1,
path move c cs ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c cs]
    & size cs' <= size cs
               ?= iff (cs ==
                       [seq ↑[i]_
                        (c ldisk)
                         | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs
         ?= iff (cs ==
                 [seq ↑[i]_(c1 ldisk) | i <- cs1])
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c1 cs]
    & size cs' <= (size cs).+1
               ?= iff (c1 :: cs ==
                       [seq ↑[i]_(c ldisk) | i <- cs'])]}
  by exists [::]; split; rewrite ?setd_id //; apply: leqif_refl; rewrite !eqxx.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1,
path move c cs ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c cs]
    & size cs' <= size cs
               ?= iff (cs ==
                       [seq ↑[i]_
                        (c ldisk)
                         | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs
         ?= iff (cs ==
                 [seq ↑[i]_(c1 ldisk) | i <- cs1])
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c1 cs]
    & size cs' <= (size cs).+1
               ?= iff (c1 :: cs ==
                       [seq ↑[i]_(c ldisk) | i <- cs'])]}
have [/eqP c1dEcd|c1dDcd] := boolP (c ldisk == c1 ldisk).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1,
path move c cs ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c cs]
    & size cs' <= size cs
               ?= iff (cs ==
                       [seq ↑[i]_
                        (c ldisk)
                         | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs
         ?= iff (cs ==
                 [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dEcd:c ldisk = c1 ldisk
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c1 cs]
    & size cs' <= (size cs).+1
               ?= iff (c1 :: cs ==
                       [seq ↑[i]_(c ldisk) | i <- cs'])]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1,
path move c cs ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c cs]
    & size cs' <= size cs
               ?= iff (cs ==
                       [seq ↑[i]_
                        (c ldisk)
                         | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs
         ?= iff (cs ==
                 [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dDcd:c ldisk != c1 ldisk
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c1 cs]
    & size cs' <= (size cs).+1
               ?= iff (c1 :: cs ==
                       [seq ↑[i]_(c ldisk) | i <- cs'])]}
  exists (cunliftr c1 :: cs1); split=> //=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1,
path move c cs ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c cs]
    & size cs' <= size cs
               ?= iff (cs ==
                       [seq ↑[i]_
                        (c ldisk)
                         | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs
         ?= iff (cs ==
                 [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dEcd:c ldisk = c1 ldisk
move ↓[c] ↓[c1] && path move ↓[c1] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1,
path move c cs ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c cs]
    & size cs' <= size cs
               ?= iff (cs ==
                       [seq ↑[i]_
                        (c ldisk)
                         | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs
         ?= iff (cs ==
                 [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dEcd:c ldisk = c1 ldisk
(size cs1).+1 <= (size cs).+1
              ?= iff (c1 :: cs ==
                      ↑[↓[c1]]_
                      (c ldisk)
                      :: [
                      seq ↑[i]_
                      (c ldisk)
                        | i <- cs1])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1,
path move c cs ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c cs]
    & size cs' <= size cs
               ?= iff (cs ==
                       [seq ↑[i]_
                        (c ldisk)
                         | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs
         ?= iff (cs ==
                 [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dDcd:c ldisk != c1 ldisk
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c1 cs]
    & size cs' <= (size cs).+1
               ?= iff (c1 :: cs ==
                       [seq ↑[i]_(c ldisk) | i <- cs'])]}
    by rewrite move_unliftr // cMc1.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1,
path move c cs ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c cs]
    & size cs' <= size cs
               ?= iff (cs ==
                       [seq ↑[i]_
                        (c ldisk)
                         | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs
         ?= iff (cs ==
                 [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dEcd:c ldisk = c1 ldisk
(size cs1).+1 <= (size cs).+1
              ?= iff (c1 :: cs ==
                      ↑[↓[c1]]_(c ldisk)
                      :: [seq ↑[i]_(c ldisk)
                            | i <- cs1])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1,
path move c cs ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c cs]
    & size cs' <= size cs
               ?= iff (cs ==
                       [seq ↑[i]_
                        (c ldisk)
                         | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs
         ?= iff (cs ==
                 [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dDcd:c ldisk != c1 ldisk
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c1 cs]
    & size cs' <= (size cs).+1
               ?= iff (c1 :: cs ==
                       [seq ↑[i]_(c ldisk) | i <- cs'])]}
  by rewrite eqseq_cons c1dEcd cunliftrK eqxx.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1,
path move c cs ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c cs]
    & size cs' <= size cs
               ?= iff (cs ==
                       [seq ↑[i]_
                        (c ldisk)
                         | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs
         ?= iff (cs ==
                 [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dDcd:c ldisk != c1 ldisk
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c1 cs]
    & size cs' <= (size cs).+1
               ?= iff (c1 :: cs ==
                       [seq ↑[i]_(c ldisk) | i <- cs'])]}
have -> : cunliftr c = cunliftr c1 by apply: move_ldisk.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1,
path move c cs ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c cs]
    & size cs' <= size cs
               ?= iff (cs ==
                       [seq ↑[i]_
                        (c ldisk)
                         | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs
         ?= iff (cs ==
                 [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dDcd:c ldisk != c1 ldisk
{cs' : seq (configuration n)
| [/\ path move ↓[c1] cs',
      last ↓[c1] cs' = ↓[last c1 cs]
    & size cs' <= (size cs).+1
               ?= iff (c1 :: cs ==
                       [seq ↑[i]_(c ldisk) | i <- cs'])]}
exists cs1; split=> //=.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1,
path move c cs ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c cs]
    & size cs' <= size cs
               ?= iff (cs ==
                       [seq ↑[i]_
                        (c ldisk)
                         | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs
         ?= iff (cs ==
                 [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dDcd:c ldisk != c1 ldisk
size cs1 <= (size cs).+1
         ?= iff (c1 :: cs ==
                 [seq ↑[i]_(c ldisk) | i <- cs1])
apply/leqifP; case: eqP=> [H|/= _]; last by rewrite ltnS S.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1,
path move c cs ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs',
      last ↓[c] cs' = ↓[last c cs]
    & size cs' <= size cs
               ?= iff (cs ==
                       [seq ↑[i]_
                        (c ldisk)
                         | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs
         ?= iff (cs ==
                 [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dDcd:c ldisk != c1 ldisk
H:c1 :: cs = [seq ↑[i]_(c ldisk) | i <- cs1]
size cs1 == (size cs).+1
by rewrite -[_.+1]/(size (c1 :: cs)) H size_map.
Qed.

(* we can restrict a path from n.+1 to n *)
Lemma pathS_restrictD n (c : configuration n.+1) c1 cs :
   path move c cs -> c1 \in cs -> c1 ldisk != c ldisk ->
   {cs'| [/\ path move ↓[c] cs', 
             last ↓[c] cs' = ↓[last c cs] & size cs' < size cs]}.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1)
  (ordinal_eqType q)
cs:seq (configuration n.+1)
path move c cs ->
c1 \in cs ->
c1 ldisk != c ldisk ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs]
    & size cs' < size cs]}
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1)
  (ordinal_eqType q)
cs:seq (configuration n.+1)
path move c cs ->
c1 \in cs ->
c1 ldisk != c ldisk ->
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs]
    & size cs' < size cs]}
move=> cPcs c1Ics c1dDcd.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1)
  (ordinal_eqType q)
cs:seq (configuration n.+1)
cPcs:path move c cs
c1Ics:c1 \in cs
c1dDcd:c1 ldisk != c ldisk
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs]
    & size cs' < size cs]}
have [cs1 [H1 H2 H3]] := pathS_restrict cPcs.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1)
  (ordinal_eqType q)
cs:seq (configuration n.+1)
cPcs:path move c cs
c1Ics:c1 \in cs
c1dDcd:c1 ldisk != c ldisk
cs1:seq (configuration n)
H1:path move ↓[c] cs1
H2:last ↓[c] cs1 = ↓[last c cs]
H3:size cs1 <= size cs
         ?= iff (cs ==
                 [seq ↑[i]_(c ldisk) | i <- cs1])
{cs' : seq (configuration n)
| [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs]
    & size cs' < size cs]}
exists cs1; split => //.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1)
  (ordinal_eqType q)
cs:seq (configuration n.+1)
cPcs:path move c cs
c1Ics:c1 \in cs
c1dDcd:c1 ldisk != c ldisk
cs1:seq (configuration n)
H1:path move ↓[c] cs1
H2:last ↓[c] cs1 = ↓[last c cs]
H3:size cs1 <= size cs
         ?= iff (cs ==
                 [seq ↑[i]_(c ldisk) | i <- cs1])
size cs1 < size cs
move/leqifP : H3; case: eqP => // cs1Ecs.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1)
  (ordinal_eqType q)
cs:seq (configuration n.+1)
cPcs:path move c cs
c1Ics:c1 \in cs
c1dDcd:c1 ldisk != c ldisk
cs1:seq (configuration n)
H1:path move ↓[c] cs1
H2:last ↓[c] cs1 = ↓[last c cs]
cs1Ecs:cs = [seq ↑[i]_(c ldisk) | i <- cs1]
size cs1 == size cs -> size cs1 < size cs
case/eqP: c1dDcd.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1)
  (ordinal_eqType q)
cs:seq (configuration n.+1)
cPcs:path move c cs
c1Ics:c1 \in cs
cs1:seq (configuration n)
H1:path move ↓[c] cs1
H2:last ↓[c] cs1 = ↓[last c cs]
cs1Ecs:cs = [seq ↑[i]_(c ldisk) | i <- cs1]
c1 ldisk = c ldisk
move: c1Ics; rewrite cs1Ecs => /mapP[x xIcs1 ->].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1)
  (ordinal_eqType q)
cs:seq (configuration n.+1)
cPcs:path move c cs
cs1:seq (configuration n)
H1:path move ↓[c] cs1
H2:last ↓[c] cs1 = ↓[last c cs]
cs1Ecs:cs = [seq ↑[i]_(c ldisk) | i <- cs1]
x:finfun_eqType (ordinal_finType n)
  (ordinal_eqType q)
xIcs1:x \in cs1
↑[x]_(c ldisk) ldisk = c ldisk
by rewrite cliftr_ldisk.
Qed.

(* connect is symmetric *)
(* there should be a shorter proof since move n is symmetric *)
Lemma connect_sym n : connect_sym (@move n).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
connect_sym move
Proof.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
connect_sym move
move=> c1 c2.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType q)
connect move c1 c2 = connect move c2 c1
apply/connectP/connectP=> [] [p H1 H2].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType q)
p:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType q))
H1:path move c1 p
H2:c2 = last c1 p
exists2
  p : seq
        (finfun_finType (ordinal_finType n)
           (ordinal_finType q)),
  path move c2 p & c1 = last c2 p
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType q)
p:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType q))
H1:path move c2 p
H2:c1 = last c2 p
exists2
  p : seq
        (finfun_finType (ordinal_finType n)
           (ordinal_finType q)),
  path move c1 p & c2 = last c1 p
  exists (rev (belast c1 p)); first by rewrite H2 path_move_rev.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType q)
p:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType q))
H1:path move c1 p
H2:c2 = last c1 p
c1 = last c2 (rev (belast c1 p))
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType q)
p:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType q))
H1:path move c2 p
H2:c1 = last c2 p
exists2
  p : seq
        (finfun_finType (ordinal_finType n)
           (ordinal_finType q)),
  path move c1 p & c2 = last c1 p
  by case: (p) H2 => [->//|c3 p1 _]; rewrite rev_cons last_rcons.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType q)
p:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType q))
H1:path move c2 p
H2:c1 = last c2 p
exists2
  p : seq
        (finfun_finType (ordinal_finType n)
           (ordinal_finType q)),
  path move c1 p & c2 = last c1 p
exists (rev (belast c2 p)); first by rewrite H2 path_move_rev.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType q)
p:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType q))
H1:path move c2 p
H2:c1 = last c2 p
c2 = last c1 (rev (belast c2 p))
by case: (p) H2 => [->//|c3 p1 _]; rewrite rev_cons last_rcons.
Qed.

End GHanoi.

Arguments perfect {q n}.
Arguments cunliftr {q n}.

Notation " ↑[ c ]_ p" := (cliftr p c) (at level 5, format "↑[ c ]_ p").
Notation " ↓[ c ]" := (cunliftr c) (at level 5, format "↓[ c ]").
Notation "`c[ p ] " := (perfect p) (format "`c[ p ]", at level 5).
Notation "`c[ p , n ] " := ((perfect p) : configuration _ n) 
  (format "`c[ p  ,  n ]", at level 5).

Lemma on_top1 k (d : disk 1) (c : configuration k 1) : on_top d c.
k:nat
d:disk 1
c:configuration k 1
on_top d c
Proof.
k:nat
d:disk 1
c:configuration k 1
on_top d c by apply/on_topP=> [] [] [] //=; case: d => [] []. Qed.

Lemma perfect_eqE n k (p1 p2 : peg k) : (`c[p1, n.+1] == `c[p2]) = (p1 == p2).
n, k:nat
p1, p2:peg k
(`c[p1 , n.+1] == `c[p2]) = (p1 == p2)
Proof.
n, k:nat
p1, p2:peg k
(`c[p1 , n.+1] == `c[p2]) = (p1 == p2)
apply/eqP/eqP => [|<-] // cp1Ecp2.
n, k:nat
p1, p2:peg k
cp1Ecp2:`c[p1] = `c[p2]
p1 = p2
rewrite -(_ : `c[p1, n.+1] sdisk = p1); last by rewrite ffunE.
n, k:nat
p1, p2:peg k
cp1Ecp2:`c[p1] = `c[p2]
`c[p1] sdisk = p2
by rewrite cp1Ecp2 ffunE.
Qed.

Section PLift.

Variables n q : nat.
Variables i : disk q.+1.
Variable r1 : rel (disk q).
Variable r2 : rel (disk q.+1).

Let p := lift i.

Hypothesis r2Rr1 : forall i j, r2 (p i) (p j) = r1 i j.

Definition plift (c : configuration q n) : configuration q.+1 n := 
  [ffun j => p (c j)].

Lemma plift_on_top c1 x : on_top x (plift c1) = on_top x c1.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1:configuration q n
x:disk n
on_top x (plift c1) = on_top x c1
Proof.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1:configuration q n
x:disk n
on_top x (plift c1) = on_top x c1
apply/on_topP/on_topP => H d; have := H d; rewrite !ffunE => H1 H2; apply: H1.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1:configuration q n
x:disk n
H:forall d1 : ordinal_finType n,
plift c1 x = plift c1 d1 -> x <= d1
d:ordinal_finType n
H2:c1 x = c1 d
p (c1 x) = p (c1 d)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1:configuration q n
x:disk n
H:forall d1 : ordinal_finType n,
c1 x = c1 d1 -> x <= d1
d:ordinal_finType n
H2:p (c1 x) = p (c1 d)
c1 x = c1 d
  by rewrite H2.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1:configuration q n
x:disk n
H:forall d1 : ordinal_finType n,
c1 x = c1 d1 -> x <= d1
d:ordinal_finType n
H2:p (c1 x) = p (c1 d)
c1 x = c1 d
by apply: lift_inj H2.
Qed.

Lemma plift_move (c1 c2 : configuration q n) :
  move r2 (plift c1) (plift c2) = move r1 c1 c2.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
move r2 (plift c1) (plift c2) = move r1 c1 c2
Proof.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
move r2 (plift c1) (plift c2) = move r1 c1 c2
apply/moveP/moveP => [] [x [H1x H2x H3x H4x]]; exists x; split => //.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
r1 (c1 x) (c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c1
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
-
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
r1 (c1 x) (c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c1
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2) by rewrite !ffunE in H1x; rewrite -r2Rr1.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c1
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
-
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c1
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2) by move=> d2 xDd2; have := H2x _ xDd2; rewrite !ffunE => /lift_inj.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c1
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
-
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c1
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2) by rewrite plift_on_top in H3x.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
-
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2) by rewrite plift_on_top in H4x.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
-
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2) by rewrite !ffunE r2Rr1.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
-
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n,
x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2) by move=> d2 /H2x; rewrite !ffunE => ->.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
-
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2) by rewrite plift_on_top.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n,
x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
by rewrite plift_on_top.
Qed.

Lemma plift_path (c1 : configuration q n) cs :
  path (move r2) (plift c1) [seq plift i | i <- cs] =
  path (move r1) c1 cs.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1:configuration q n
cs:seq (configuration q n)
path (move r2) (plift c1) [seq plift i | i <- cs] =
path (move r1) c1 cs 
Proof.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1:configuration q n
cs:seq (configuration q n)
path (move r2) (plift c1) [seq plift i | i <- cs] =
path (move r1) c1 cs
elim: cs c1 => //= c2 cs IH c1.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c2:configuration q n
cs:seq (configuration q n)
IH:forall c1 : configuration q n,
path (move r2) (plift c1) [seq plift i | i <- cs] =
path (move r1) c1 cs
c1:configuration q n
move r2 (plift c1) (plift c2) &&
path (move r2) (plift c2) [seq plift i | i <- cs] =
move r1 c1 c2 && path (move r1) c2 cs
by rewrite plift_move IH.
Qed.

Lemma gdist_plift (c1 c2 : configuration q n) :
 connect (move r1) c1 c2 ->
  `d[plift c1, plift c2]_(move r2)  <=  `d[c1, c2]_(move r1).
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
connect (move r1) c1 c2 ->
`d[plift c1, plift c2]_(move r2) <=
`d[c1, c2]_(move r1)
Proof.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
connect (move r1) c1 c2 ->
`d[plift c1, plift c2]_(move r2) <=
`d[c1, c2]_(move r1)
move=> /gpath_connect [p1 p1H].
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
p1:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType q))
p1H:gpath (move r1) c1 c2 p1
`d[plift c1, plift c2]_(move r2) <=
`d[c1, c2]_(move r1)
rewrite (gpath_dist p1H) -(size_map plift).
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
p1:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType q))
p1H:gpath (move r1) c1 c2 p1
`d[plift c1, plift c2]_(move r2) <=
size [seq plift i | i <- p1]
apply: gdist_path_le; first by rewrite plift_path (gpath_path p1H).
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
p1:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType q))
p1H:gpath (move r1) c1 c2 p1
last (plift c1) [seq plift i | i <- p1] = plift c2
by rewrite last_map (gpath_last p1H).
Qed.

Lemma plift_perfect p1 : plift `c[p1] = `c[lift i p1].
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
p1:peg q
plift `c[p1] = `c[lift i p1]
Proof.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
p1:peg q
plift `c[p1] = `c[lift i p1] by apply/ffunP => j; rewrite !ffunE. Qed.

Lemma cdisjoint_plift_perfect m c : cdisjoint (plift c) `c[i, m].
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
m:nat
c:configuration q n
cdisjoint (plift c) `c[i , m] 
Proof.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
m:nat
c:configuration q n
cdisjoint (plift c) `c[i , m]
apply/cdisjointP=> i1 j1; rewrite !ffunE /p; apply/eqP/val_eqP => /=.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1,
r2 (p i) (p j) = r1 i j
m:nat
c:configuration q n
i1:ordinal_finType n
j1:ordinal_finType m
bump i (c i1) != i
by rewrite eq_sym neq_bump.
Qed.

End PLift.

Section Crlift.

Variable q : nat.
Variable p : peg q.+1.
Variable r1 : rel (disk q).
Variable r2 : rel (disk q.+1).

Hypothesis r2Irr : irreflexive r2.
Hypothesis r1Rr2 : forall i j : disk q, r1 i j = r2 (lift p i) (lift p j).

Lemma move_liftln m n (c1 c2 : configuration q m) :
    move r2 (cliftln n p (plift p c1)) (cliftln n p (plift p c2)) = 
    move r1 c1 c2.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
move r2 (cliftln n p (plift p c1))
  (cliftln n p (plift p c2)) = move r1 c1 c2
Proof.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
move r2 (cliftln n p (plift p c1))
  (cliftln n p (plift p c2)) = move r1 c1 c2
apply/idP/idP=> H; last first.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
move r2 (cliftln n p (plift p c1))
  (cliftln n p (plift p c2))
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1))
  (cliftln n p (plift p c2))
move r1 c1 c2
  apply: move_mergel_inv => //.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
cdisjoint (plift p c1) `c[p]
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
cdisjoint (plift p c2) `c[p]
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
move r2 (plift p c1) (plift p c2)
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1))
  (cliftln n p (plift p c2))
move r1 c1 c2
  -
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
cdisjoint (plift p c1) `c[p]
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
cdisjoint (plift p c2) `c[p]
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
move r2 (plift p c1) (plift p c2)
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1))
  (cliftln n p (plift p c2))
move r1 c1 c2 by apply: cdisjoint_plift_perfect.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
cdisjoint (plift p c2) `c[p]
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
move r2 (plift p c1) (plift p c2)
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1))
  (cliftln n p (plift p c2))
move r1 c1 c2
  -
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
cdisjoint (plift p c2) `c[p]
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
move r2 (plift p c1) (plift p c2)
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1))
  (cliftln n p (plift p c2))
move r1 c1 c2 by apply: cdisjoint_plift_perfect.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
move r2 (plift p c1) (plift p c2)
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1))
  (cliftln n p (plift p c2))
move r1 c1 c2
  by rewrite (@plift_move _ _ _ r1).
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1))
  (cliftln n p (plift p c2))
move r1 c1 c2
have := move_mergel r2Irr H.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1))
  (cliftln n p (plift p c2))
move r2 (plift p c1) (plift p c2) -> move r1 c1 c2
by rewrite (@plift_move _ _ _ r1).
Qed.

Lemma path_liftln m n (c : configuration q m) (cs : seq (configuration _ _)) :
    path (move r2) (cliftln n p (plift p c)) (map (cliftln n p \o (plift p)) cs) = 
    path (move r1) c cs.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c:configuration q m
cs:seq (configuration q m)
path (move r2) (cliftln n p (plift p c))
  [seq (cliftln n p \o plift p) i | i <- cs] =
path (move r1) c cs
Proof.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c:configuration q m
cs:seq (configuration q m)
path (move r2) (cliftln n p (plift p c))
  [seq (cliftln n p \o plift p) i | i <- cs] =
path (move r1) c cs by elim: cs c => //= c1 cs1 IH c; rewrite move_liftln IH. Qed.

Lemma connect_liftln m n (c1 c2 : configuration q m) : 
  connect (move r1) c1 c2 -> 
  connect (move r2) (cliftln n p (plift p c1)) 
                    (cliftln n p (plift p c2)).
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
connect (move r1) c1 c2 ->
connect (move r2) (cliftln n p (plift p c1))
  (cliftln n p (plift p c2))
Proof.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
connect (move r1) c1 c2 ->
connect (move r2) (cliftln n p (plift p c1))
  (cliftln n p (plift p c2))
move=> /connectP[x]; rewrite -(path_liftln n) => Hp Hl.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
x:seq
  (finfun_finType (ordinal_finType m)
     (ordinal_finType q))
Hp:path (move r2) (cliftln n p (plift p c1))
  [seq (cliftln n p \o plift p) i | i <- x]
Hl:c2 = last c1 x
connect (move r2) (cliftln n p (plift p c1))
  (cliftln n p (plift p c2))
apply/connectP; eexists; first exact: Hp.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
x:seq
  (finfun_finType (ordinal_finType m)
     (ordinal_finType q))
Hp:path (move r2) (cliftln n p (plift p c1))
  [seq (cliftln n p \o plift p) i | i <- x]
Hl:c2 = last c1 x
cliftln n p (plift p c2) =
last (cliftln n p (plift p c1))
  [seq (cliftln n p \o plift p) i | i <- x]
by rewrite Hl [RHS]last_map.
Qed.

Lemma gdist_liftln m n (c1 c2 : configuration q m) : 
  connect (move r1) c1 c2 ->
  gdist (move r2) (cliftln n p (plift p c1)) (cliftln n p (plift p c2)) <= 
  gdist (move r1) c1 c2.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
connect (move r1) c1 c2 ->
`d[cliftln n p (plift p c1), cliftln n p (plift p c2)]_
(move r2) <= `d[c1, c2]_(move r1)
Proof.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
connect (move r1) c1 c2 ->
`d[cliftln n p (plift p c1), cliftln n p (plift p c2)]_
(move r2) <= `d[c1, c2]_(move r1)
move=> /gpath_connect[p1 p1H].
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
p1:seq
  (finfun_finType (ordinal_finType m)
     (ordinal_finType q))
p1H:gpath (move r1) c1 c2 p1
`d[cliftln n p (plift p c1), cliftln n p (plift p c2)]_
(move r2) <= `d[c1, c2]_(move r1)
rewrite (gpath_dist p1H) -(size_map (cliftln n p \o plift p)).
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
p1:seq
  (finfun_finType (ordinal_finType m)
     (ordinal_finType q))
p1H:gpath (move r1) c1 c2 p1
`d[cliftln n p (plift p c1), cliftln n p (plift p c2)]_
(move r2) <=
size [seq (cliftln n p \o plift p) i | i <- p1]
apply: gdist_path_le; first by rewrite path_liftln (gpath_path p1H).
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
p1:seq
  (finfun_finType (ordinal_finType m)
     (ordinal_finType q))
p1H:gpath (move r1) c1 c2 p1
last (cliftln n p (plift p c1))
  [seq (cliftln n p \o plift p) i | i <- p1] =
cliftln n p (plift p c2)
by rewrite [LHS]last_map (gpath_last p1H).
Qed.

Lemma crliftn_perfect n m p1 : cliftln n p `c[p1] = cliftrn m p1 `c[p].
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
n, m:nat
p1:peg q.+1
cliftln n p `c[p1] = cliftrn m p1 `c[p]
Proof.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q,
r1 i j = r2 (lift p i) (lift p j)
n, m:nat
p1:peg q.+1
cliftln n p `c[p1] = cliftrn m p1 `c[p] by []. Qed.

End Crlift.

(******************************************************************************)
(*  Other peg                                                                 *)
(******************************************************************************)

Definition opeg n (p1 p2 : peg n) :=
  odflt (if p1 <= p2 then p1 else p2) [pick i | (i != p1) && (i != p2)].

Lemma opeg_sym n (p1 p2 : peg n) : opeg p1 p2 = opeg p2 p1.
n:nat
p1, p2:peg n
opeg p1 p2 = opeg p2 p1
Proof.
n:nat
p1, p2:peg n
opeg p1 p2 = opeg p2 p1
rewrite /opeg; case: ltngtP => H;
  try by congr odflt; apply: eq_pick => p; rewrite andbC.
n:nat
p1, p2:peg n
H:p1 = p2
odflt p1 [pick i | i != p1  & i != p2] =
odflt p2 [pick i | i != p2  & i != p1]
suff -> : p1 = p2 by [].
n:nat
p1, p2:peg n
H:p1 = p2
p1 = p2
by apply/val_eqP/eqP.
Qed.

Lemma opegDl n (p1 p2 : peg n.+3) : opeg p1 p2 != p1.
n:nat
p1, p2:peg n.+3
opeg p1 p2 != p1
Proof.
n:nat
p1, p2:peg n.+3
opeg p1 p2 != p1
rewrite /opeg; case: pickP => [x /andP[]//| HD].
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 =>
 (i != p1) && (i != p2)) =1 xpred0
odflt (if p1 <= p2 then p1 else p2) None != p1
have D (p3 p4 : peg n.+3) : (p3 == p4) = (val p3 == val p4).
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 =>
 (i != p1) && (i != p2)) =1 xpred0
p3, p4:peg n.+3
(p3 == p4) = (val p3 == val p4)
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 =>
 (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3,
(p3 == p4) = (val p3 == val p4)
odflt (if p1 <= p2 then p1 else p2) None != p1
  by apply/eqP/idP => /val_eqP.
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 =>
 (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3,
(p3 == p4) = (val p3 == val p4)
odflt (if p1 <= p2 then p1 else p2) None != p1
have := HD sdisk; have := HD (inord 1); have := HD (inord 2).
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 =>
 (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3,
(p3 == p4) = (val p3 == val p4)
(inord 2 != p1) && (inord 2 != p2) = false ->
(inord 1 != p1) && (inord 1 != p2) = false ->
(sdisk != p1) && (sdisk != p2) = false ->
odflt (if p1 <= p2 then p1 else p2) None != p1
rewrite !D /= !inordK //.
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 =>
 (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3,
(p3 == p4) = (val p3 == val p4)
(2 != p1) && (2 != p2) = false ->
(1 != p1) && (1 != p2) = false ->
(0 != p1) && (0 != p2) = false ->
(if p1 <= p2 then p1 else p2) != p1
by case: {HD}p1 => [] [|[|[|p1 Hp1]]] /=;
   case: p2 => [] [|[|[|p2 Hp2]]].
Qed.

Lemma opegDr n (p1 p2 : peg n.+3) : opeg p1 p2 != p2.
n:nat
p1, p2:peg n.+3
opeg p1 p2 != p2
Proof.
n:nat
p1, p2:peg n.+3
opeg p1 p2 != p2
rewrite /opeg; case: pickP => [x /andP[]//| HD].
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 =>
 (i != p1) && (i != p2)) =1 xpred0
odflt (if p1 <= p2 then p1 else p2) None != p2
have D (p3 p4 : peg n.+3) : (p3 == p4) = (val p3 == val p4).
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 =>
 (i != p1) && (i != p2)) =1 xpred0
p3, p4:peg n.+3
(p3 == p4) = (val p3 == val p4)
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 =>
 (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3,
(p3 == p4) = (val p3 == val p4)
odflt (if p1 <= p2 then p1 else p2) None != p2
  by apply/eqP/idP => /val_eqP.
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 =>
 (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3,
(p3 == p4) = (val p3 == val p4)
odflt (if p1 <= p2 then p1 else p2) None != p2
have := HD sdisk; have := HD (inord 1); have := HD (inord 2).
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 =>
 (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3,
(p3 == p4) = (val p3 == val p4)
(inord 2 != p1) && (inord 2 != p2) = false ->
(inord 1 != p1) && (inord 1 != p2) = false ->
(sdisk != p1) && (sdisk != p2) = false ->
odflt (if p1 <= p2 then p1 else p2) None != p2
rewrite !D /= !inordK //.
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 =>
 (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3,
(p3 == p4) = (val p3 == val p4)
(2 != p1) && (2 != p2) = false ->
(1 != p1) && (1 != p2) = false ->
(0 != p1) && (0 != p2) = false ->
(if p1 <= p2 then p1 else p2) != p2
by case: {HD}p1 => [] [|[|[|p1 Hp1]]] /=;
   case: p2 => [] [|[|[|p2 Hp2]]].
Qed.

Notation "`p[ p1 , p2 ] " := (opeg p1 p2)
    (format "`p[ p1 ,  p2 ]", at level 5).

Lemma move_liftr_perfect q n (hrel : rel (peg q)) p1 p2 p3 :
  hrel p1 p2 -> p1 != p3 -> p2 != p3 -> move hrel ↑[`c[p3, n]]_p1 ↑[`c[p3]]_p2.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hrel p1 p2 ->
p1 != p3 ->
p2 != p3 -> move hrel ↑[`c[p3 , n]]_p1 ↑[`c[p3]]_p2
Proof.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hrel p1 p2 ->
p1 != p3 ->
p2 != p3 -> move hrel ↑[`c[p3 , n]]_p1 ↑[`c[p3]]_p2
move=> p1Rp2 p1Dp3 p2Dp3.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
move hrel ↑[`c[p3 , n]]_p1 ↑[`c[p3]]_p2
apply: (@move_mergel_inv _ _ 1).
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
cdisjoint `c[p1] `c[p3]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
cdisjoint `c[p2] `c[p3]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
move hrel `c[p1] `c[p2]
-
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
cdisjoint `c[p1] `c[p3]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
cdisjoint `c[p2] `c[p3]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
move hrel `c[p1] `c[p2] by apply/cdisjointP => i j; rewrite !ffunE.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
cdisjoint `c[p2] `c[p3]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
move hrel `c[p1] `c[p2]
-
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
cdisjoint `c[p2] `c[p3]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
move hrel `c[p1] `c[p2] by apply/cdisjointP => i j; rewrite !ffunE.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
move hrel `c[p1] `c[p2]
apply/moveP; exists ldisk; split; try by apply: on_top1.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
hrel (`c[p1] ldisk) (`c[p2] ldisk)
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
forall d2 : ordinal_finType 1,
ldisk != d2 -> `c[p1] d2 = `c[p2] d2
  by rewrite !ffunE.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
forall d2 : ordinal_finType 1,
ldisk != d2 -> `c[p1] d2 = `c[p2] d2
by case => [] [].
Qed.

Lemma gdist_liftr_perfect q n (hrel : rel (peg q)) p1 p2 p3 :
  irreflexive hrel -> hrel p1 p2 -> p1 != p3 -> p2 != p3 ->
  `d[↑[perfect p3 : configuration q n]_p1, ↑[perfect p3]_p2]_(move hrel) = 1.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
irreflexive hrel ->
hrel p1 p2 ->
p1 != p3 ->
p2 != p3 ->
`d[↑[`c[p3 , n]]_p1, ↑[`c[p3]]_p2]_(move hrel) = 1
Proof.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
irreflexive hrel ->
hrel p1 p2 ->
p1 != p3 ->
p2 != p3 ->
`d[↑[`c[p3 , n]]_p1, ↑[`c[p3]]_p2]_(move hrel) = 1
move=> hirr p1Rp2 p1Dp3 p2Dp3.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
`d[↑[`c[p3 , n]]_p1, ↑[`c[p3]]_p2]_(move hrel) = 1
apply/eqP; rewrite eqn_leq; apply/andP; split.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
`d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_(move hrel) <= 1
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
0 < `d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_(move hrel)
  rewrite -[1]/(size [:: cliftr p2 `c[p3, n]]).
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
`d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_(move hrel) <=
size [:: ↑[`c[p3 , n]]_p2]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
0 < `d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_(move hrel)
  apply: gdist_path_le => //=.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
move hrel ↑[`c[p3]]_p1 ↑[`c[p3]]_p2 && true
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
0 < `d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_(move hrel)
  by rewrite move_liftr_perfect.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
0 < `d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_(move hrel)
case E : gdist => //.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
E:`d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_(move hrel) = 0
0 < 0
move/eqP: E; rewrite gdist_eq0 => /eqP E.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
E:↑[`c[p3]]_p1 = ↑[`c[p3]]_p2
0 < 0
have := cliftr_ldisk p1 `c[p3, n].
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
E:↑[`c[p3]]_p1 = ↑[`c[p3]]_p2
↑[`c[p3]]_p1 ldisk = p1 -> 0 < 0
rewrite E cliftr_ldisk => p2Ep1.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
E:↑[`c[p3]]_p1 = ↑[`c[p3]]_p2
p2Ep1:p2 = p1
0 < 0
by have := hirr p1; rewrite -{2}p2Ep1 p1Rp2.
Qed.

(*****************************************************************************)
(*  Regular relation                                                         *)
(*****************************************************************************)

Section Rrel.

Variable n : nat.

Definition rrel : rel (peg n) := [rel x  y | x != y].

Definition rirr : irreflexive rrel.
n:nat
irreflexive rrel
by move=> x; apply/eqP.
Qed.

Definition rsym : symmetric rrel.
n:nat
symmetric rrel
by move=> x y; rewrite /rrel /= eq_sym.
Qed.

Definition rmove m : rel (configuration n m) := move rrel.

End Rrel.

Section Srel.

Variable n : nat.

Definition srel : rel (peg n) := [rel x y  : peg n | (x != y) && (x * y == 0)].
Definition sirr : irreflexive srel.
n:nat
irreflexive srel
by move=> x; apply/idP/negP; rewrite negb_and eqxx.
Qed.

Definition ssym : symmetric srel.
n:nat
symmetric srel
by move=> x y; rewrite /srel /= mulnC eq_sym.
Qed.

Definition smove m : rel (configuration n m) := move srel.

End Srel.


(******************************************************************************)
(*  Linear relation                                                           *)
(******************************************************************************)

Section Lrel.

Variable n : nat.

Definition lrel : rel (peg n) := 
  [rel x y : peg n | (x.+1 == y) || (y.+1 == x)].

Definition lirr : irreflexive lrel.
n:nat
irreflexive lrel
Proof.
n:nat
irreflexive lrel by move=> k; rewrite /lrel /= (gtn_eqF (leqnn _)). Qed.

Definition lsym : symmetric lrel.
n:nat
symmetric lrel
Proof.
n:nat
symmetric lrel by move=> x y; rewrite /lrel /= orbC.
Qed.

Definition lmove m : rel (configuration n m) := move lrel.

End Lrel.

Arguments rmove {n m}.
Arguments lmove {n m}.
Arguments smove {n m}.

Lemma connect_move p n (c1 c2 : configuration p.+3 n) : 
   connect rmove c1 c2.
p, n:nat
c1, c2:configuration p.+3 n
connect rmove c1 c2
Proof.
p, n:nat
c1, c2:configuration p.+3 n
connect rmove c1 c2
elim: n c1 c2 => [c1 c2 | n IH c1 c2].
p:nat
c1, c2:configuration p.+3 0
connect rmove c1 c2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
connect rmove c1 c2
  rewrite (_ : c1 = c2) ?connect0 //.
p:nat
c1, c2:configuration p.+3 0
c1 = c2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
connect rmove c1 c2
  by apply/ffunP=> [] [].
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
connect rmove c1 c2
rewrite -[c1]cunliftrK -[c2]cunliftrK.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
connect rmove ↑[↓[c1]]_(c1 ldisk) ↑[↓[c2]]_(c2 ldisk)
set p1 := c1 ldisk; set p2 := c2 ldisk.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
connect rmove ↑[↓[c1]]_p1 ↑[↓[c2]]_p2
have [<-|/eqP p1Dp2] := p1 =P p2.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
connect rmove ↑[↓[c1]]_p1 ↑[↓[c2]]_p1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
connect rmove ↑[↓[c1]]_p1 ↑[↓[c2]]_p2
  by apply: connect_liftr => // i; rewrite rirr.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
connect rmove ↑[↓[c1]]_p1 ↑[↓[c2]]_p2
pose p3 := opeg p1 p2.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
connect rmove ↑[↓[c1]]_p1 ↑[↓[c2]]_p2
apply: connect_trans (_ : connect _ (cliftr p1 `c[p3]) _).
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
connect rmove ↑[↓[c1]]_p1 ↑[`c[p3]]_p1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
connect rmove ↑[`c[p3]]_p1 ↑[↓[c2]]_p2
  apply: connect_liftr; first by apply: rirr.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
connect (move (rrel (n:=p.+3))) ↓[c1] `c[p3]
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
connect rmove ↑[`c[p3]]_p1 ↑[↓[c2]]_p2
  by apply: IH.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
connect rmove ↑[`c[p3]]_p1 ↑[↓[c2]]_p2
apply: connect_trans (_ : connect _ (cliftr p2 `c[p3]) _); last first.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
connect rmove ↑[`c[p3]]_p2 ↑[↓[c2]]_p2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
connect rmove ↑[`c[p3]]_p1 ↑[`c[p3]]_p2
  apply: connect_liftr; first by apply: rirr.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
connect (move (rrel (n:=p.+3))) `c[p3] ↓[c2]
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
connect rmove ↑[`c[p3]]_p1 ↑[`c[p3]]_p2
  by apply: IH.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
connect rmove ↑[`c[p3]]_p1 ↑[`c[p3]]_p2
apply: connect1.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
rmove ↑[`c[p3]]_p1 ↑[`c[p3]]_p2
apply: move_liftr_perfect => //.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
p1 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
p2 != p3
  rewrite eq_sym; apply: opegDl.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
p2 != p3
rewrite eq_sym; apply: opegDr.
Qed.

Lemma gdist_leq_move p n (c1 c2 : configuration p.+3 n) : 
   `d[c1, c2]_rmove <= (2 ^ n).-1.
p, n:nat
c1, c2:configuration p.+3 n
`d[c1, c2]_rmove <= (2 ^ n).-1
Proof.
p, n:nat
c1, c2:configuration p.+3 n
`d[c1, c2]_rmove <= (2 ^ n).-1
elim: n c1 c2 => [c1 c2 | n IH c1 c2].
p:nat
c1, c2:configuration p.+3 0
`d[c1, c2]_rmove <= (2 ^ 0).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
`d[c1, c2]_rmove <= (2 ^ n.+1).-1
  rewrite (_ : c1 = c2) ?gdist0 //.
p:nat
c1, c2:configuration p.+3 0
c1 = c2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
`d[c1, c2]_rmove <= (2 ^ n.+1).-1
  by apply/ffunP=> [] [] [].
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
`d[c1, c2]_rmove <= (2 ^ n.+1).-1
rewrite -[c1]cunliftrK -[c2]cunliftrK.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
`d[↑[↓[c1]]_(c1 ldisk), ↑[↓[c2]]_(c2 ldisk)]_rmove <=
(2 ^ n.+1).-1
set p1 := c1 ldisk; set p2 := c2 ldisk.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
have [<-|/eqP p1Dp2] := p1 =P p2.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p1]_rmove <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
  apply: leq_trans.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p1]_rmove <= ?Goal0
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
?Goal0 <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
    apply: gdist_liftr => [i|]; first by rewrite rirr.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
connect (move (rrel (n:=p.+3))) ↓[c1] ↓[c2]
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
`d[↓[c1], ↓[c2]]_(move (rrel (n:=p.+3))) <=
(2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
    apply: connect_move.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
`d[↓[c1], ↓[c2]]_(move (rrel (n:=p.+3))) <=
(2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
  apply: leq_trans; first by apply: IH.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
(2 ^ n).-1 <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
  rewrite -ltnS !prednK ?expn_gt0 //.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
2 ^ n <= 2 ^ n.+1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
  by rewrite leq_exp2l.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
pose p3 := opeg p1 p2.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
apply: leq_trans.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= ?Goal
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
?Goal <= (2 ^ n.+1).-1
  apply: (@gdist_triangular _ _ _ _ (cliftr p1 `c[p3])).
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
`d[↑[↓[c1]]_p1, ↑[`c[p3]]_p1]_rmove +
`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
rewrite expnS mul2n -addnn.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
`d[↑[↓[c1]]_p1, ↑[`c[p3]]_p1]_rmove +
`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <=
(2 ^ n + 2 ^ n).-1
have tnP : 0 < 2 ^ n by rewrite expn_gt0.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[↓[c1]]_p1, ↑[`c[p3]]_p1]_rmove +
`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <=
(2 ^ n + 2 ^ n).-1
rewrite -(prednK tnP) addSn /=.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[↓[c1]]_p1, ↑[`c[p3]]_p1]_rmove +
`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <=
(2 ^ n).-1 + (2 ^ n).-1.+1
apply: leq_add.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[↓[c1]]_p1, ↑[`c[p3]]_p1]_rmove <= (2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1.+1
  apply: leq_trans.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[↓[c1]]_p1, ↑[`c[p3]]_p1]_rmove <= ?Goal0
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
?Goal0 <= (2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1.+1
    apply: gdist_liftr => [i|]; first by rewrite rirr.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
connect (move (rrel (n:=p.+3))) ↓[c1] `c[p3]
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↓[c1], `c[p3]]_(move (rrel (n:=p.+3))) <=
(2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1.+1
    by apply: connect_move.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↓[c1], `c[p3]]_(move (rrel (n:=p.+3))) <=
(2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1.+1
  by apply: IH.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1.+1
apply: leq_trans.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= ?Goal
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
?Goal <= (2 ^ n).-1.+1
  apply: (@gdist_triangular _ _ _ _ (cliftr p2 `c[p3])).
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_rmove +
`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1.+1
rewrite gdist_liftr_perfect ?ltnS //; last 3 first.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
irreflexive (rrel (n:=p.+3))
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p1 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p2 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1
-
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
irreflexive (rrel (n:=p.+3))
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p1 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p2 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1 by apply: rirr.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p1 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p2 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1
-
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p1 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p2 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1 by rewrite eq_sym opegDl.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p2 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1
-
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p2 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1 by rewrite eq_sym opegDr.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1
apply: leq_trans.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= ?Goal
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
?Goal <= (2 ^ n).-1
  apply: gdist_liftr => [i|]; first by rewrite rirr.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
connect (move (rrel (n:=p.+3))) `c[p3] ↓[c2]
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[`c[p3], ↓[c2]]_(move (rrel (n:=p.+3))) <=
(2 ^ n).-1
  by apply: connect_move.
p, n:nat
IH:forall c1 c2 : configuration p.+3 n,
`d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[`c[p3], ↓[c2]]_(move (rrel (n:=p.+3))) <=
(2 ^ n).-1
by apply: IH.
Qed.

Definition sorted (s : seq nat) := 
  forall i j, i < size s -> j < size s -> (nth 0 s i < nth 0 s j) = (i < j).

Lemma sorted_cons a s : sorted (a :: s) -> sorted s.
a:nat
s:seq nat
sorted (a :: s) -> sorted s
Proof.
a:nat
s:seq nat
sorted (a :: s) -> sorted s by move=> H i j iH jH; rewrite -[in RHS]ltnS -[in RHS]H.
Qed.

Lemma sorted_iota i j : sorted (iota i j).
i, j:nat
sorted (iota i j)
Proof.
i, j:nat
sorted (iota i j)
move=> i1 j1; rewrite size_iota => i1Lj j1Lj.
i, j, i1, j1:nat
i1Lj:i1 < j
j1Lj:j1 < j
(nth 0 (iota i j) i1 < nth 0 (iota i j) j1) =
(i1 < j1)
by rewrite !nth_iota // ltn_add2l.
Qed.

Lemma sorted_skip a b s : sorted (a :: b :: s) -> sorted (a :: s).
a, b:nat
s:seq nat
sorted [:: a, b & s] -> sorted (a :: s)
Proof.
a, b:nat
s:seq nat
sorted [:: a, b & s] -> sorted (a :: s)
move=> Hs [|i] [|j] iH jH //=; first by rewrite ltnn.
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
j:nat
iH:0 < size (a :: s)
jH:j.+1 < size (a :: s)
(a < nth 0 s j) = (0 < j.+1)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i:nat
iH:i.+1 < size (a :: s)
jH:0 < size (a :: s)
(nth 0 s i < a) = (i.+1 < 0)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i, j:nat
iH:i.+1 < size (a :: s)
jH:j.+1 < size (a :: s)
(nth 0 s i < nth 0 s j) = (i.+1 < j.+1)
-
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
j:nat
iH:0 < size (a :: s)
jH:j.+1 < size (a :: s)
(a < nth 0 s j) = (0 < j.+1)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i:nat
iH:i.+1 < size (a :: s)
jH:0 < size (a :: s)
(nth 0 s i < a) = (i.+1 < 0)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i, j:nat
iH:i.+1 < size (a :: s)
jH:j.+1 < size (a :: s)
(nth 0 s i < nth 0 s j) = (i.+1 < j.+1) by rewrite (Hs 0 j.+2).
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i:nat
iH:i.+1 < size (a :: s)
jH:0 < size (a :: s)
(nth 0 s i < a) = (i.+1 < 0)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i, j:nat
iH:i.+1 < size (a :: s)
jH:j.+1 < size (a :: s)
(nth 0 s i < nth 0 s j) = (i.+1 < j.+1)
-
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i:nat
iH:i.+1 < size (a :: s)
jH:0 < size (a :: s)
(nth 0 s i < a) = (i.+1 < 0)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i, j:nat
iH:i.+1 < size (a :: s)
jH:j.+1 < size (a :: s)
(nth 0 s i < nth 0 s j) = (i.+1 < j.+1) by rewrite (Hs i.+2 0).
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i, j:nat
iH:i.+1 < size (a :: s)
jH:j.+1 < size (a :: s)
(nth 0 s i < nth 0 s j) = (i.+1 < j.+1)
by rewrite (Hs i.+2 j.+2).
Qed.

Lemma sorted_filter (s : seq nat) (p : pred nat) :
  sorted s -> sorted (filter p s).
s:seq nat
p:pred nat
sorted s -> sorted [seq x <- s | p x]
Proof.
s:seq nat
p:pred nat
sorted s -> sorted [seq x <- s | p x]
have F a s1 i :
   sorted (a :: s1) -> i < size (filter p s1) -> a < nth 0 (filter p s1) i.
s:seq nat
p:pred nat
a:nat
s1:seq nat
i:nat
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
sorted s -> sorted [seq x <- s | p x]
  elim: s1 i => //= b s1 IH i abS.
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
IH:forall i : nat,
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
i:nat
abS:sorted [:: a, b & s1]
i <
size
  (if p b
   then b :: [seq x <- s1 | p x]
   else [seq x <- s1 | p x]) ->
a <
nth 0
  (if p b
   then b :: [seq x <- s1 | p x]
   else [seq x <- s1 | p x]) i
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
sorted s -> sorted [seq x <- s | p x]
  have [pbT|pbF] := boolP (p b).
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
IH:forall i : nat,
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
i:nat
abS:sorted [:: a, b & s1]
pbT:p b
i < size (b :: [seq x <- s1 | p x]) ->
a < nth 0 (b :: [seq x <- s1 | p x]) i
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
IH:forall i : nat,
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
i:nat
abS:sorted [:: a, b & s1]
pbF:~~ p b
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
sorted s -> sorted [seq x <- s | p x]
    case: i => [|i1] /= sH; first by rewrite (abS 0 1).
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
IH:forall i : nat,
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
abS:sorted [:: a, b & s1]
pbT:p b
i1:nat
sH:i1.+1 < (size [seq x <- s1 | p x]).+1
a < nth 0 [seq x <- s1 | p x] i1
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
IH:forall i : nat,
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
i:nat
abS:sorted [:: a, b & s1]
pbF:~~ p b
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
sorted s -> sorted [seq x <- s | p x]
    apply: IH => //.
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
abS:sorted [:: a, b & s1]
pbT:p b
i1:nat
sH:i1.+1 < (size [seq x <- s1 | p x]).+1
sorted (a :: s1)
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
IH:forall i : nat,
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
i:nat
abS:sorted [:: a, b & s1]
pbF:~~ p b
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
sorted s -> sorted [seq x <- s | p x]
    by apply: sorted_skip abS.
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
IH:forall i : nat,
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
i:nat
abS:sorted [:: a, b & s1]
pbF:~~ p b
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
sorted s -> sorted [seq x <- s | p x]
  apply: IH.
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
i:nat
abS:sorted [:: a, b & s1]
pbF:~~ p b
sorted (a :: s1)
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
sorted s -> sorted [seq x <- s | p x]
  by apply: sorted_skip abS.
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
sorted s -> sorted [seq x <- s | p x]
elim: s => //= a s IH aS.
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sorted
  (if p a
   then a :: [seq x <- s | p x]
   else [seq x <- s | p x])
have sS := sorted_cons aS.
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
sorted
  (if p a
   then a :: [seq x <- s | p x]
   else [seq x <- s | p x])
have [paT|paF] := boolP (p a); last by apply: IH.
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
sorted (a :: [seq x <- s | p x])
move=> [|i] [|j] iH jH /=.
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
iH, jH:0 < size (a :: [seq x <- s | p x])
(a < a) = (0 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
j:nat
iH:0 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(a < nth 0 [seq x <- s | p x] j) = (0 < j.+1)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:0 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < a) = (i.+1 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i, j:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i <
 nth 0 [seq x <- s | p x] j) = (i.+1 < j.+1)
-
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
iH, jH:0 < size (a :: [seq x <- s | p x])
(a < a) = (0 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
j:nat
iH:0 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(a < nth 0 [seq x <- s | p x] j) = (0 < j.+1)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:0 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < a) = (i.+1 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i, j:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i <
 nth 0 [seq x <- s | p x] j) = (i.+1 < j.+1) by rewrite ltnn.
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
j:nat
iH:0 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(a < nth 0 [seq x <- s | p x] j) = (0 < j.+1)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:0 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < a) = (i.+1 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i, j:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i <
 nth 0 [seq x <- s | p x] j) = (i.+1 < j.+1)
-
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
j:nat
iH:0 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(a < nth 0 [seq x <- s | p x] j) = (0 < j.+1)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:0 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < a) = (i.+1 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i, j:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i <
 nth 0 [seq x <- s | p x] j) = (i.+1 < j.+1) by rewrite F.
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:0 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < a) = (i.+1 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i, j:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i <
 nth 0 [seq x <- s | p x] j) = (i.+1 < j.+1)
-
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:0 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < a) = (i.+1 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i, j:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i <
 nth 0 [seq x <- s | p x] j) = (i.+1 < j.+1) by rewrite ltnNge ltnW // F.
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat),
sorted (a :: s1) ->
i < size [seq x <- s1 | p x] ->
a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i, j:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i <
 nth 0 [seq x <- s | p x] j) = (i.+1 < j.+1)
by rewrite ltnS (IH sS).
Qed.

Lemma enum_ord_inord m : (enum 'I_m.+1) = [seq inord i | i <- iota 0 m.+1].
m:nat
enum 'I_m.+1 = [seq inord i | i <- iota 0 m.+1]
Proof.
m:nat
enum 'I_m.+1 = [seq inord i | i <- iota 0 m.+1]
rewrite -val_ord_enum -map_comp /=.
m:nat
enum 'I_m.+1 =
[seq ([eta inord] \o nat_of_ord (n:=m.+1)) i
   | i <- ord_enum m.+1]
rewrite enumT unlock /=.
m:nat
ord_enum m.+1 =
[seq ([eta inord] \o nat_of_ord (n:=m.+1)) i
   | i <- ord_enum m.+1]
elim: (ord_enum _) => //= a l <-.
m:nat
a:'I_m.+1
l:seq 'I_m.+1
a :: l = inord a :: l
by rewrite inord_val.
Qed.

(* To be reworked ! *)
Lemma sorted_enum_val (m : nat) (s : {set 'I_m}) (i j : 'I_#|s|) :
   (enum_val i) < (enum_val j) = (i < j).
m:nat
s:{set 'I_m}
i, j:'I_#|s|
(enum_val i < enum_val j) = (i < j)
Proof.
m:nat
s:{set 'I_m}
i, j:'I_#|s|
(enum_val i < enum_val j) = (i < j)
case: m s i j => [s|m s i j].
s:{set 'I_0}
forall i j : 'I_#|s|,
(enum_val i < enum_val j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
(enum_val i < enum_val j) = (i < j)
  rewrite (_ : s = set0).
s:{set 'I_0}
forall i j : 'I_#|set0|,
(enum_val i < enum_val j) = (i < j)
s:{set 'I_0}
s = set0
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
(enum_val i < enum_val j) = (i < j)
    case=> m H j; apply: False_ind.
s:{set 'I_0}
m:nat
H:m < #|set0|
j:'I_#|set0|
False
s:{set 'I_0}
s = set0
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
(enum_val i < enum_val j) = (i < j)
    by rewrite cards0 in H.
s:{set 'I_0}
s = set0
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
(enum_val i < enum_val j) = (i < j)
  by apply/setP=> [] [].
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
(enum_val i < enum_val j) = (i < j) 
have := ltn_ord i; have := ltn_ord j; rewrite {2 4}cardE.
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
j < size (enum s) ->
i < size (enum s) ->
(enum_val i < enum_val j) = (i < j)
rewrite /enum_val /= /(enum _) -enumT enum_ord_inord => iL jL.
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
(nth (enum_default i)
   [seq x <- [seq inord i | i <- iota 0 m.+1]
      | mem s x] i <
 nth (enum_default j)
   [seq x <- [seq inord i | i <- iota 0 m.+1]
      | mem s x] j) = (i < j)
have <-// := @nth_map ('I_m.+1) (enum_default i) nat 0 (@nat_of_ord m.+1).
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
(nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] i <
 nth (enum_default j)
   [seq x <- [seq inord i | i <- iota 0 m.+1]
      | mem s x] j) = (i < j)
have <-// := @nth_map ('I_m.+1) (enum_default j) nat 0 (@nat_of_ord m.+1).
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
(nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] i <
 nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] j) = (i < j)
have F k1 k2 :  k1 + k2 <= m.+1 ->
  [seq (nat_of_ord i) | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] =
  (filter (fun i0 => mem s (inord i0))  (iota k1 k2)).
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
k1, k2:nat
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
F:forall k1 k2 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] i <
 nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] j) = (i < j)
  elim: k2 k1 => //= k2 IH k1 k1k2Lm.
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
k2:nat
IH:forall k1 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & i \in s] =
[seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
[seq i
   | i <- if inord k1 \in s
          then
           inord k1
           :: [seq i <- [seq inord i0
                           | i0 <- iota k1.+1 k2]
                 | i \in s]
          else
           [seq i <- [seq inord i0
                        | i0 <- iota k1.+1 k2]
              | i \in s]] =
(if inord k1 \in s
 then k1 :: [seq i0 <- iota k1.+1 k2 | inord i0 \in s]
 else [seq i0 <- iota k1.+1 k2 | inord i0 \in s])
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
F:forall k1 k2 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] i <
 nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] j) = (i < j)
  case: (_ \in _) => //=.
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
k2:nat
IH:forall k1 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & i \in s] =
[seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
inord k1
:: [seq i
      | i <- [seq inord i0 | i0 <- iota k1.+1 k2]
      & i \in s] =
k1 :: [seq i0 <- iota k1.+1 k2 | inord i0 \in s]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
k2:nat
IH:forall k1 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & i \in s] =
[seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
[seq i
   | i <- [seq inord i0 | i0 <- iota k1.+1 k2]
   & i \in s] =
[seq i0 <- iota k1.+1 k2 | inord i0 \in s]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
F:forall k1 k2 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] i <
 nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] j) = (i < j)
  rewrite inordK //.
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
k2:nat
IH:forall k1 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & i \in s] =
[seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
k1
:: [seq i
      | i <- [seq inord i0 | i0 <- iota k1.+1 k2]
      & i \in s] =
k1 :: [seq i0 <- iota k1.+1 k2 | inord i0 \in s]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
k2:nat
IH:forall k1 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & i \in s] =
[seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
k1 < m.+1
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
k2:nat
IH:forall k1 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & i \in s] =
[seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
[seq i
   | i <- [seq inord i0 | i0 <- iota k1.+1 k2]
   & i \in s] =
[seq i0 <- iota k1.+1 k2 | inord i0 \in s]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
F:forall k1 k2 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] i <
 nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] j) = (i < j)
  rewrite IH //.
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
k2:nat
IH:forall k1 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & i \in s] =
[seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
k1.+1 + k2 <= m.+1
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
k2:nat
IH:forall k1 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & i \in s] =
[seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
k1 < m.+1
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
k2:nat
IH:forall k1 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & i \in s] =
[seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
[seq i
   | i <- [seq inord i0 | i0 <- iota k1.+1 k2]
   & i \in s] =
[seq i0 <- iota k1.+1 k2 | inord i0 \in s]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
F:forall k1 k2 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] i <
 nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] j) = (i < j)
  by rewrite addSnnS.
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
k2:nat
IH:forall k1 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & i \in s] =
[seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
k1 < m.+1
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
k2:nat
IH:forall k1 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & i \in s] =
[seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
[seq i
   | i <- [seq inord i0 | i0 <- iota k1.+1 k2]
   & i \in s] =
[seq i0 <- iota k1.+1 k2 | inord i0 \in s]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
F:forall k1 k2 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] i <
 nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] j) = (i < j)
  by apply: leq_trans k1k2Lm; rewrite -addSnnS leq_addr.
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
k2:nat
IH:forall k1 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & i \in s] =
[seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
[seq i
   | i <- [seq inord i0 | i0 <- iota k1.+1 k2]
   & i \in s] =
[seq i0 <- iota k1.+1 k2 | inord i0 \in s]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
F:forall k1 k2 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] i <
 nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] j) = (i < j)
  apply: IH.
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
k2, k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
k1.+1 + k2 <= m.+1
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
F:forall k1 k2 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] i <
 nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] j) = (i < j)
  by rewrite addSnnS.
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
F:forall k1 k2 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] i <
 nth 0
   [seq i
      | i <- [seq inord i | i <- iota 0 m.+1]
      & mem s i] j) = (i < j)
rewrite F //.
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
F:forall k1 k2 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] i <
 nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] j) =
(i < j)
have : j < size ([seq i0 <- iota 0 m.+1 | mem s (inord i0)]).
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
F:forall k1 k2 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
j < size [seq i0 <- iota 0 m.+1 | mem s (inord i0)]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
F:forall k1 k2 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
j < size [seq i0 <- iota 0 m.+1 | mem s (inord i0)] ->
(nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] i <
 nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] j) =
(i < j)
  by move: iL; rewrite -F // size_map.
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
F:forall k1 k2 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
j < size [seq i0 <- iota 0 m.+1 | mem s (inord i0)] ->
(nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] i <
 nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] j) =
(i < j)
have : i < size ([seq i0 <- iota 0 m.+1 | mem s (inord i0)])
  by move: jL; rewrite -F // size_map.
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
F:forall k1 k2 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
i < size [seq i0 <- iota 0 m.+1 | mem s (inord i0)] ->
j < size [seq i0 <- iota 0 m.+1 | mem s (inord i0)] ->
(nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] i <
 nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] j) =
(i < j)
apply: sorted_filter => //.
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
jL:i <
size
  [seq x <- [seq inord i | i <- iota 0 m.+1]
     | mem s x]
F:forall k1 k2 : nat,
k1 + k2 <= m.+1 ->
[seq i
   | i <- [seq inord i0 | i0 <- iota k1 k2]
   & mem s i] =
[seq i0 <- iota k1 k2 | mem s (inord i0)]
sorted (iota 0 m.+1)
by apply: sorted_iota.
Qed.

Section ISetd.

(* Number of disks *)
Variable n : nat.
(* Subset of disks *)
Variable sd : {set disk n}.
(* Number of pegs *)
Variable k : nat.

(* relations on peg *)
Variable rel : rel (peg k). 

Definition cset (c : configuration k n) : configuration k #|sd| := 
  [ffun i => c (enum_val i)].

Lemma on_top_cset c d (dIsd : d \in sd) : 
  on_top d c -> on_top (enum_rank_in dIsd d) (cset c).
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
on_top d c -> on_top (enum_rank_in dIsd d) (cset c)
Proof.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
on_top d c -> on_top (enum_rank_in dIsd d) (cset c)
move=> /= /on_topP dO.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
on_top (enum_rank_in dIsd d) (cset c)
apply/on_topP => /= d1 H.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
enum_rank_in dIsd d <= d1
rewrite leq_eqVlt; case: eqP => //= /eqP dDd1.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1
enum_rank_in dIsd d < d1
rewrite -[d1](enum_valK_in dIsd) -sorted_enum_val !enum_rankK_in //; last first.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1
enum_val d1 \in sd
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1
d < enum_val d1
  by apply: enum_valP.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1
d < enum_val d1
rewrite ltn_neqAle.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1
(d != enum_val d1) && (d <= enum_val d1)
case: eqP => [/eqP /val_eqP dEd1 | /eqP dDd1' /=].
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1
dEd1:d = enum_val d1
~~ true && (d <= enum_val d1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
d <= enum_val d1
  by case/eqP: dDd1; rewrite {2}dEd1 enum_valK_in.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
d <= enum_val d1
rewrite !ffunE enum_rankK_in // in H.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
H:c d = c (enum_val d1)
d <= enum_val d1
by apply: dO.
Qed.

Lemma move_cset (c1 c2 : configuration k n) : 
  move rel c1 c2 -> (cset c1) != (cset c2) ->
  move rel (cset c1) (cset c2).
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
move rel c1 c2 ->
cset c1 != cset c2 -> move rel (cset c1) (cset c2)
Proof.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
move rel c1 c2 ->
cset c1 != cset c2 -> move rel (cset c1) (cset c2)
move => /moveP [d [dH1 dH2 dH3 dH4]] c1Dc2.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
move rel (cset c1) (cset c2)
have [dIsd|dNIsd] := boolP (d \in sd); last first.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dNIsd:d \notin sd
move rel (cset c1) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
move rel (cset c1) (cset c2)
  case/eqP: c1Dc2.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd
cset c1 = cset c2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
move rel (cset c1) (cset c2)
  apply/ffunP => i; rewrite !ffunE.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd
i:ordinal_finType #|sd|
c1 (enum_val i) = c2 (enum_val i)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
move rel (cset c1) (cset c2)
  apply: dH2.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd
i:ordinal_finType #|sd|
d != enum_val i
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
move rel (cset c1) (cset c2)
  apply: contra dNIsd => /eqP->.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
i:ordinal_finType #|sd|
enum_val i \in sd
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
move rel (cset c1) (cset c2)
  by apply: enum_valP.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
move rel (cset c1) (cset c2)
apply/moveP; exists (enum_rank_in dIsd d); split => /=.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
rel (cset c1 (enum_rank_in dIsd d))
  (cset c2 (enum_rank_in dIsd d))
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
forall d2 : 'I_#|sd|,
enum_rank_in dIsd d != d2 -> cset c1 d2 = cset c2 d2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
-
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
rel (cset c1 (enum_rank_in dIsd d))
  (cset c2 (enum_rank_in dIsd d))
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
forall d2 : 'I_#|sd|,
enum_rank_in dIsd d != d2 -> cset c1 d2 = cset c2 d2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2) by rewrite !ffunE !enum_rankK_in //.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
forall d2 : 'I_#|sd|,
enum_rank_in dIsd d != d2 -> cset c1 d2 = cset c2 d2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
-
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
forall d2 : 'I_#|sd|,
enum_rank_in dIsd d != d2 -> cset c1 d2 = cset c2 d2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2) move=> /= d2 dDd2.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2
cset c1 d2 = cset c2 d2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
  rewrite !ffunE.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2
c1 (enum_val d2) = c2 (enum_val d2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
  apply: dH2.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2
d != enum_val d2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
  rewrite -[d](enum_rankK_in dIsd) //.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2
enum_val (enum_rank_in dIsd d) != enum_val d2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
  by apply /eqP => /enum_val_inj /eqP; rewrite (negPf dDd2).
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
-
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2) by apply: on_top_cset.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
by apply: on_top_cset.
Qed.

Lemma path_cset (c : configuration _ _) cs :
    path (move rel) c cs ->
    path (move rel) (cset c) (rm_rep (cset c) [seq (cset i) | i <- cs]).
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
cs:seq (configuration k n)
path (move rel) c cs ->
path (move rel) (cset c)
  (rm_rep (cset c) [seq cset i | i <- cs])
Proof.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
cs:seq (configuration k n)
path (move rel) c cs ->
path (move rel) (cset c)
  (rm_rep (cset c) [seq cset i | i <- cs])
elim: cs c => //= c1 cs IH c => /andP[cMc1 c1Pcs].
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
path (move rel) (cset c)
  (rm_rep (cset c) [seq cset i | i <- cs])
c:configuration k n
cMc1:move rel c c1
c1Pcs:path (move rel) c1 cs
path (move rel) (cset c)
  (if cset c == cset c1
   then rm_rep (cset c1) [seq cset i | i <- cs]
   else
    cset c1 :: rm_rep (cset c1) [seq cset i | i <- cs])
case: eqP => [->|/eqP cDc1 /=]; first by apply: IH; rewrite ?c2V.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
path (move rel) (cset c)
  (rm_rep (cset c) [seq cset i | i <- cs])
c:configuration k n
cMc1:move rel c c1
c1Pcs:path (move rel) c1 cs
cDc1:cset c != cset c1
move rel (cset c) (cset c1) &&
path (move rel) (cset c1)
  (rm_rep (cset c1) [seq cset i | i <- cs])
by rewrite move_cset => //=; first by apply: IH; rewrite ?c2V.
Qed.

Lemma gdist_cset c1 c2 cs : 
    last c1 cs = c2 -> path (move rel) c1 cs ->
   `d[cset c1, cset c2]_(move rel) <= size cs.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
cs:seq (configuration k n)
last c1 cs = c2 ->
path (move rel) c1 cs ->
`d[cset c1, cset c2]_(move rel) <= size cs
Proof.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
cs:seq (configuration k n)
last c1 cs = c2 ->
path (move rel) c1 cs ->
`d[cset c1, cset c2]_(move rel) <= size cs
move=> cL cPcs.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
`d[cset c1, cset c2]_(move rel) <= size cs
have := size_rm_rep (cset c1) [seq (cset i) | i <- cs].
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
size (rm_rep (cset c1) [seq cset i | i <- cs]) <=
size [seq cset i | i <- cs] ->
`d[cset c1, cset c2]_(move rel) <= size cs
rewrite size_map; move/(leq_trans _); apply.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
`d[cset c1, cset c2]_(move rel) <=
size (rm_rep (cset c1) [seq cset i | i <- cs])
apply: gdist_path_le; first by apply: path_cset.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
last (cset c1)
  (rm_rep (cset c1) [seq cset i | i <- cs]) = cset c2
by rewrite last_rm_rep last_map cL.
Qed.

Lemma gpath_cset c1 c2 cs : 
    gpath (move rel) c1 c2 cs ->
   `d[cset c1, cset c2]_(move rel) <= `d[c1, c2]_(move rel).
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gpath (move rel) c1 c2 cs ->
`d[cset c1, cset c2]_(move rel) <=
`d[c1, c2]_(move rel)
Proof.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gpath (move rel) c1 c2 cs ->
`d[cset c1, cset c2]_(move rel) <=
`d[c1, c2]_(move rel)
move=> gH.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs
`d[cset c1, cset c2]_(move rel) <=
`d[c1, c2]_(move rel)
rewrite (gpath_dist gH); apply: gdist_cset => //; first apply: gpath_last gH.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs
path (move rel) c1 cs
by apply: gpath_path gH.
Qed.

End ISetd.

Arguments gpath [T].

Section CSet.

(* Number of disks *)
Variable n : nat.
(* cut limit *)
Variable t : nat.
Variable tLn : t <= n.
(* Number of pegs *)
Variable k : nat.

(* relations on peg *)
Variable rel : rel (peg k).
Hypothesis irH : irreflexive rel.

Definition ccut (c : configuration k n) : configuration k t := 
  [ffun i => c (widen_ord tLn i)].

Lemma ordinalK (d : disk n) (dLt : d < t) : widen_ord tLn (Ordinal dLt) = d.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
d:disk n
dLt:d < t
widen_ord tLn (Ordinal dLt) = d
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
d:disk n
dLt:d < t
widen_ord tLn (Ordinal dLt) = d by apply: val_inj. Qed.

Lemma codom_cut (c : configuration k n) (s : seq (peg k)) :
  codom c \subset s -> codom (ccut c) \subset s.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
s:seq (peg k)
codom c \subset s -> codom (ccut c) \subset s
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
s:seq (peg k)
codom c \subset s -> codom (ccut c) \subset s
move=> H; apply/subsetP => i /mapP[j _ ->].
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
s:seq (peg k)
H:codom c \subset s
i:ordinal_finType k
j:ordinal_finType t
ccut c j \in s
by rewrite ffunE; apply: (subsetP H); apply: codom_f.
Qed.

Lemma s2f_cut (c : configuration k n) (p : disk k) : 
  s2f ([set i | c i == p] :&: isO n t) =
  s2f [set i | ccut c i == p].
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
s2f ([set i | c i == p] :&: isO n t) =
s2f [set i | ccut c i == p]
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
s2f ([set i | c i == p] :&: isO n t) =
s2f [set i | ccut c i == p]
apply/fsetP=> /= i.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
i:nat
(i \in s2f ([set i | c i == p] :&: isO n t)) =
(i \in s2f [set i | ccut c i == p])
apply/imfsetP/imfsetP => [] /= [j]; rewrite !inE.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
i:nat
j:'I_n
(c j == p) && (j < t) ->
i = j ->
exists2 x : 'I_t,
  x \in [set i | ccut c i == p] & i = x
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
i:nat
j:'I_t
ccut c j == p ->
i = j ->
exists2 x : 'I_n,
  x \in [set i | c i == p] :&: isO n t & i = x
  case/andP => cjEp jLt ->.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
i:nat
j:'I_n
cjEp:c j == p
jLt:j < t
exists2 x : 'I_t,
  x \in [set i | ccut c i == p] & j = x
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
i:nat
j:'I_t
ccut c j == p ->
i = j ->
exists2 x : 'I_n,
  x \in [set i | c i == p] :&: isO n t & i = x
  by exists (Ordinal jLt); rewrite //= inE !ffunE ordinalK.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
i:nat
j:'I_t
ccut c j == p ->
i = j ->
exists2 x : 'I_n,
  x \in [set i | c i == p] :&: isO n t & i = x
rewrite !ffunE => cjEp ->; exists (widen_ord tLn j) => //=.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
i:nat
j:'I_t
cjEp:c (widen_ord tLn j) == p
widen_ord tLn j \in [set i | c i == p] :&: isO n t
by rewrite !inE /= cjEp /=.
Qed.

Lemma on_top_cut c (d : disk n) (dLr : d < t) : 
  on_top d c -> on_top (Ordinal dLr) (ccut c).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:d < t
on_top d c -> on_top (Ordinal dLr) (ccut c)
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:d < t
on_top d c -> on_top (Ordinal dLr) (ccut c)
move=> /= /on_topP dO.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:d < t
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
on_top (Ordinal dLr) (ccut c)
apply/on_topP => /= d1 H.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:d < t
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_t
H:ccut c (Ordinal dLr) = ccut c d1
d <= d1
rewrite leq_eqVlt; case: eqP => //= /eqP dDd1.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:d < t
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_t
H:ccut c (Ordinal dLr) = ccut c d1
dDd1:d != d1
d < d1
rewrite ltn_neqAle dDd1 /=.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:d < t
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_t
H:ccut c (Ordinal dLr) = ccut c d1
dDd1:d != d1
d <= d1
apply: (dO (widen_ord tLn d1)) => //.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:d < t
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_t
H:ccut c (Ordinal dLr) = ccut c d1
dDd1:d != d1
c d = c (widen_ord tLn d1)
by move: H; rewrite !ffunE ordinalK.
Qed.

Lemma move_cut (c1 c2 : configuration k n) : 
  move rel c1 c2 -> (ccut c1) != (ccut c2) ->
  move rel (ccut c1) (ccut c2).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
move rel c1 c2 ->
ccut c1 != ccut c2 -> move rel (ccut c1) (ccut c2)
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
move rel c1 c2 ->
ccut c1 != ccut c2 -> move rel (ccut c1) (ccut c2)
move => /moveP [d [dH1 dH2 dH3 dH4]] c1Dc2.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
move rel (ccut c1) (ccut c2)
have [dLt|tLd] := leqP t d.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
dLt:t <= d
move rel (ccut c1) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
move rel (ccut c1) (ccut c2)
  case/eqP: c1Dc2.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dLt:t <= d
ccut c1 = ccut c2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
move rel (ccut c1) (ccut c2)
  apply/ffunP => i; rewrite !ffunE.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dLt:t <= d
i:ordinal_finType t
c1 (widen_ord tLn i) = c2 (widen_ord tLn i)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
move rel (ccut c1) (ccut c2)
  apply: dH2.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
dLt:t <= d
i:ordinal_finType t
d != widen_ord tLn i
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
move rel (ccut c1) (ccut c2)
  by rewrite -val_eqE /= neq_ltn (leq_trans _ dLt) // orbT.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
move rel (ccut c1) (ccut c2)
apply/moveP; exists (Ordinal tLd); split => /=.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
rel (ccut c1 (Ordinal tLd)) (ccut c2 (Ordinal tLd))
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
forall d2 : 'I_t,
Ordinal tLd != d2 -> ccut c1 d2 = ccut c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c2)
-
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
rel (ccut c1 (Ordinal tLd)) (ccut c2 (Ordinal tLd))
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
forall d2 : 'I_t,
Ordinal tLd != d2 -> ccut c1 d2 = ccut c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c2) by rewrite !ffunE // ordinalK.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
forall d2 : 'I_t,
Ordinal tLd != d2 -> ccut c1 d2 = ccut c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c2)
-
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
forall d2 : 'I_t,
Ordinal tLd != d2 -> ccut c1 d2 = ccut c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c2) move=> /= d2; rewrite !ffunE -val_eqE /= => dDd2.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
d2:'I_t
dDd2:d != d2
c1 (widen_ord tLn d2) = c2 (widen_ord tLn d2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c2)
  by apply: dH2; rewrite -val_eqE /=.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c2)
-
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c2) by apply: on_top_cut.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c2)
by apply: on_top_cut.
Qed.

Lemma path_cut (c : configuration _ _) cs :
    path (move rel) c cs ->
    path (move rel) (ccut c) (rm_rep (ccut c) [seq (ccut i) | i <- cs]).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
cs:seq (configuration k n)
path (move rel) c cs ->
path (move rel) (ccut c)
  (rm_rep (ccut c) [seq ccut i | i <- cs])
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
cs:seq (configuration k n)
path (move rel) c cs ->
path (move rel) (ccut c)
  (rm_rep (ccut c) [seq ccut i | i <- cs])
elim: cs c => //= c1 cs IH c => /andP[cMc1 c1Pcs].
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
path (move rel) (ccut c)
  (rm_rep (ccut c) [seq ccut i | i <- cs])
c:configuration k n
cMc1:move rel c c1
c1Pcs:path (move rel) c1 cs
path (move rel) (ccut c)
  (if ccut c == ccut c1
   then rm_rep (ccut c1) [seq ccut i | i <- cs]
   else
    ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs])
case: eqP => [->|/eqP cDc1 /=]; first by apply: IH; rewrite ?c2V.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
path (move rel) (ccut c)
  (rm_rep (ccut c) [seq ccut i | i <- cs])
c:configuration k n
cMc1:move rel c c1
c1Pcs:path (move rel) c1 cs
cDc1:ccut c != ccut c1
move rel (ccut c) (ccut c1) &&
path (move rel) (ccut c1)
  (rm_rep (ccut c1) [seq ccut i | i <- cs])
by rewrite move_cut => //=; first by apply: IH; rewrite ?c2V.
Qed.

Lemma gdist_cut c1 c2 cs : 
    last c1 cs = c2 -> path (move rel) c1 cs ->
   `d[ccut c1, ccut c2]_(move rel) <= size cs.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
last c1 cs = c2 ->
path (move rel) c1 cs ->
`d[ccut c1, ccut c2]_(move rel) <= size cs
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
last c1 cs = c2 ->
path (move rel) c1 cs ->
`d[ccut c1, ccut c2]_(move rel) <= size cs
move=> cL cPcs.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
`d[ccut c1, ccut c2]_(move rel) <= size cs
have := size_rm_rep (ccut c1) [seq (ccut i) | i <- cs].
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
size (rm_rep (ccut c1) [seq ccut i | i <- cs]) <=
size [seq ccut i | i <- cs] ->
`d[ccut c1, ccut c2]_(move rel) <= size cs
rewrite size_map; move/(leq_trans _); apply.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
`d[ccut c1, ccut c2]_(move rel) <=
size (rm_rep (ccut c1) [seq ccut i | i <- cs])
apply: gdist_path_le; first by apply: path_cut.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
last (ccut c1)
  (rm_rep (ccut c1) [seq ccut i | i <- cs]) = ccut c2
by rewrite last_rm_rep last_map cL.
Qed.

Lemma gpath_cut c1 c2 cs : 
    gpath (move rel) c1 c2 cs ->
   `d[ccut c1, ccut c2]_(move rel) <= `d[c1, c2]_(move rel).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gpath (move rel) c1 c2 cs ->
`d[ccut c1, ccut c2]_(move rel) <=
`d[c1, c2]_(move rel)
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gpath (move rel) c1 c2 cs ->
`d[ccut c1, ccut c2]_(move rel) <=
`d[c1, c2]_(move rel)
move=> gH.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs
`d[ccut c1, ccut c2]_(move rel) <=
`d[c1, c2]_(move rel)
rewrite (gpath_dist gH); apply: gdist_cut => //; first apply: gpath_last gH.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs
path (move rel) c1 cs
by apply: gpath_path gH.
Qed.

Lemma tuc_subproof i : i < n - t -> i + t < n.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
i:nat
i < n - t -> i + t < n
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
i:nat
i < n - t -> i + t < n by move=> iLnt; rewrite -(subnK tLn) ltn_add2r. Qed.

Definition tuc_ord (i : disk (n - t)) : disk n := 
   Ordinal (tuc_subproof (ltn_ord i)).

Lemma otuc_subproof i : i < n -> t <= i -> i - t < n - t.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
i:nat
i < n -> t <= i -> i - t < n - t
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
i:nat
i < n -> t <= i -> i - t < n - t 
move=> iLn tLi; apply: ltn_sub2r => //.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
i:nat
iLn:i < n
tLi:t <= i
t < n
by apply: leq_ltn_trans iLn.
Qed.

Definition otuc (i : disk n) (tLi : t <= i) : disk (n - t) :=
   Ordinal (otuc_subproof (ltn_ord i) tLi).

Lemma otucK (d : disk n) (tLd : t <= d) : tuc_ord (otuc tLd) = d.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
d:disk n
tLd:t <= d
tuc_ord (otuc tLd) = d
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
d:disk n
tLd:t <= d
tuc_ord (otuc tLd) = d by apply: val_inj; rewrite /= subnK. Qed.

Definition ctuc (c : configuration k n) : configuration k (n - t) := 
  [ffun i => c (tuc_ord i)].

Lemma on_top_tuc c (d : disk n) (dLr : t <= d) : 
  on_top d c -> on_top (otuc dLr) (ctuc c).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:t <= d
on_top d c -> on_top (otuc dLr) (ctuc c)
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:t <= d
on_top d c -> on_top (otuc dLr) (ctuc c)
move=> /= /on_topP dO.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:t <= d
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
on_top (otuc dLr) (ctuc c)
apply/on_topP => /= d1 H.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:t <= d
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_(n - t)
H:ctuc c (otuc dLr) = ctuc c d1
d - t <= d1
rewrite leq_eqVlt; case: eqP => //= /eqP dDd1.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:t <= d
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_(n - t)
H:ctuc c (otuc dLr) = ctuc c d1
dDd1:d - t != d1
d - t < d1
rewrite ltn_neqAle dDd1 /= leq_subLR addnC.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:t <= d
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_(n - t)
H:ctuc c (otuc dLr) = ctuc c d1
dDd1:d - t != d1
d <= d1 + t
apply: (dO (tuc_ord d1)) => //.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:t <= d
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_(n - t)
H:ctuc c (otuc dLr) = ctuc c d1
dDd1:d - t != d1
c d = c (tuc_ord d1)
by move: H; rewrite !ffunE otucK.
Qed.

Lemma move_tuc (c1 c2 : configuration k n) : 
  move rel c1 c2 -> (ctuc c1) != (ctuc c2) ->
  move rel (ctuc c1) (ctuc c2).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
move rel c1 c2 ->
ctuc c1 != ctuc c2 -> move rel (ctuc c1) (ctuc c2)
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
move rel c1 c2 ->
ctuc c1 != ctuc c2 -> move rel (ctuc c1) (ctuc c2)
move => /moveP [d [dH1 dH2 dH3 dH4]] c1Dc2.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
move rel (ctuc c1) (ctuc c2)
have [dLt|tLd] := leqP t d; last first.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
tLd:d < t
move rel (ctuc c1) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
move rel (ctuc c1) (ctuc c2)
  case/eqP: c1Dc2.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
tLd:d < t
ctuc c1 = ctuc c2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
move rel (ctuc c1) (ctuc c2)
  apply/ffunP => i; rewrite !ffunE.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
tLd:d < t
i:ordinal_finType (n - t)
c1 (tuc_ord i) = c2 (tuc_ord i)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
move rel (ctuc c1) (ctuc c2)
  apply: dH2.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
tLd:d < t
i:ordinal_finType (n - t)
d != tuc_ord i
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
move rel (ctuc c1) (ctuc c2)
  by rewrite -val_eqE /= neq_ltn (leq_trans tLd _) // leq_addl.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
move rel (ctuc c1) (ctuc c2)
apply/moveP; exists (otuc dLt); split => /=.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
rel (ctuc c1 (otuc dLt)) (ctuc c2 (otuc dLt))
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
forall d2 : 'I_(n - t),
otuc dLt != d2 -> ctuc c1 d2 = ctuc c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c2)
-
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
rel (ctuc c1 (otuc dLt)) (ctuc c2 (otuc dLt))
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
forall d2 : 'I_(n - t),
otuc dLt != d2 -> ctuc c1 d2 = ctuc c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c2) by rewrite !ffunE // otucK.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
forall d2 : 'I_(n - t),
otuc dLt != d2 -> ctuc c1 d2 = ctuc c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c2)
-
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
forall d2 : 'I_(n - t),
otuc dLt != d2 -> ctuc c1 d2 = ctuc c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c2) move=> /= d2; rewrite !ffunE -val_eqE /= => dDd2.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
d2:'I_(n - t)
dDd2:d - t != d2
c1 (tuc_ord d2) = c2 (tuc_ord d2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c2)
  by apply: dH2; rewrite -val_eqE /= -(subnK dLt) eqn_add2r.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c2)
-
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c2) by apply: on_top_tuc.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c2)
by apply: on_top_tuc.
Qed.

Lemma path_tuc (c : configuration _ _) cs :
    path (move rel) c cs ->
    path (move rel) (ctuc c) (rm_rep (ctuc c) [seq (ctuc i) | i <- cs]).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
cs:seq (configuration k n)
path (move rel) c cs ->
path (move rel) (ctuc c)
  (rm_rep (ctuc c) [seq ctuc i | i <- cs])
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
cs:seq (configuration k n)
path (move rel) c cs ->
path (move rel) (ctuc c)
  (rm_rep (ctuc c) [seq ctuc i | i <- cs])
elim: cs c => //= c1 cs IH c => /andP[cMc1 c1Pcs].
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
path (move rel) (ctuc c)
  (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
cMc1:move rel c c1
c1Pcs:path (move rel) c1 cs
path (move rel) (ctuc c)
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
case: eqP => [->|/eqP cDc1 /=]; first by apply: IH; rewrite ?c2V.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
path (move rel) (ctuc c)
  (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
cMc1:move rel c c1
c1Pcs:path (move rel) c1 cs
cDc1:ctuc c != ctuc c1
move rel (ctuc c) (ctuc c1) &&
path (move rel) (ctuc c1)
  (rm_rep (ctuc c1) [seq ctuc i | i <- cs])
by rewrite move_tuc => //=; first by apply: IH; rewrite ?c2V.
Qed.

Lemma gdist_tuc c1 c2 cs : 
    last c1 cs = c2 -> path (move rel) c1 cs ->
   `d[ctuc c1, ctuc c2]_(move rel) <= size cs.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
last c1 cs = c2 ->
path (move rel) c1 cs ->
`d[ctuc c1, ctuc c2]_(move rel) <= size cs
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
last c1 cs = c2 ->
path (move rel) c1 cs ->
`d[ctuc c1, ctuc c2]_(move rel) <= size cs
move=> cL cPcs.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
`d[ctuc c1, ctuc c2]_(move rel) <= size cs
have := size_rm_rep (ctuc c1) [seq (ctuc i) | i <- cs].
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
size (rm_rep (ctuc c1) [seq ctuc i | i <- cs]) <=
size [seq ctuc i | i <- cs] ->
`d[ctuc c1, ctuc c2]_(move rel) <= size cs
rewrite size_map; move/(leq_trans _); apply.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
`d[ctuc c1, ctuc c2]_(move rel) <=
size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])
apply: gdist_path_le; first by apply: path_tuc.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
last (ctuc c1)
  (rm_rep (ctuc c1) [seq ctuc i | i <- cs]) = ctuc c2
by rewrite last_rm_rep last_map cL.
Qed.

Lemma gpath_tuc c1 c2 cs : 
    gpath (move rel) c1 c2 cs ->
   `d[ctuc c1, ctuc c2]_(move rel) <= `d[c1, c2]_(move rel).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gpath (move rel) c1 c2 cs ->
`d[ctuc c1, ctuc c2]_(move rel) <=
`d[c1, c2]_(move rel)
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gpath (move rel) c1 c2 cs ->
`d[ctuc c1, ctuc c2]_(move rel) <=
`d[c1, c2]_(move rel)
move=> gH.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs
`d[ctuc c1, ctuc c2]_(move rel) <=
`d[c1, c2]_(move rel)
rewrite (gpath_dist gH); apply: gdist_tuc => //; first apply: gpath_last gH.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs
path (move rel) c1 cs
by apply: gpath_path gH.
Qed.

Lemma size_cut_tuc (c : configuration _ _) cs :
    path (move rel) c cs ->
    size cs = 
     (size (rm_rep (ccut c) [seq (ccut i) | i <- cs]) +
      size (rm_rep (ctuc c) [seq (ctuc i) | i <- cs]))%nat.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
cs:seq (configuration k n)
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
cs:seq (configuration k n)
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
elim: cs c => //= c1 cs IH c /andP[/moveP[d [dH1 dH2 dH3 dH4]] c1Pcs].
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
(size cs).+1 =
size
  (if ccut c == ccut c1
   then rm_rep (ccut c1) [seq ccut i | i <- cs]
   else
    ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
have cdDc1d : c d != c1 d.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
c d != c1 d
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
(size cs).+1 =
size
  (if ccut c == ccut c1
   then rm_rep (ccut c1) [seq ccut i | i <- cs]
   else
    ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
  by have /idP/negP := irH (c d); apply: contra => /eqP {2}->.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
(size cs).+1 =
size
  (if ccut c == ccut c1
   then rm_rep (ccut c1) [seq ccut i | i <- cs]
   else
    ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
have [tLd|dLt] := leqP t d; last first.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
(size cs).+1 =
size
  (if ccut c == ccut c1
   then rm_rep (ccut c1) [seq ccut i | i <- cs]
   else
    ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 =
size
  (if ccut c == ccut c1
   then rm_rep (ccut c1) [seq ccut i | i <- cs]
   else
    ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
  rewrite ifN /= ?addSn; last first.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
ccut c != ccut c1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
(size cs).+1 =
(size (rm_rep (ccut c1) [seq ccut i | i <- cs]) +
 size
   (if ctuc c == ctuc c1
    then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
    else
     ctuc c1
     :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 =
size
  (if ccut c == ccut c1
   then rm_rep (ccut c1) [seq ccut i | i <- cs]
   else
    ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
    apply/eqP => /ffunP /(_ (Ordinal dLt)).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
ccut c (Ordinal dLt) = ccut c1 (Ordinal dLt) -> False
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
(size cs).+1 =
(size (rm_rep (ccut c1) [seq ccut i | i <- cs]) +
 size
   (if ctuc c == ctuc c1
    then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
    else
     ctuc c1
     :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 =
size
  (if ccut c == ccut c1
   then rm_rep (ccut c1) [seq ccut i | i <- cs]
   else
    ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
    by rewrite !ffunE ordinalK => /eqP; rewrite (negPf cdDc1d).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
(size cs).+1 =
(size (rm_rep (ccut c1) [seq ccut i | i <- cs]) +
 size
   (if ctuc c == ctuc c1
    then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
    else
     ctuc c1
     :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 =
size
  (if ccut c == ccut c1
   then rm_rep (ccut c1) [seq ccut i | i <- cs]
   else
    ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
  rewrite ifT; last first.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
ctuc c == ctuc c1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
(size cs).+1 =
(size (rm_rep (ccut c1) [seq ccut i | i <- cs]) +
 size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 =
size
  (if ccut c == ccut c1
   then rm_rep (ccut c1) [seq ccut i | i <- cs]
   else
    ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
    apply/eqP/ffunP=> i; rewrite !ffunE dH2 //=.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
i:ordinal_finType (n - t)
d != tuc_ord i
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
(size cs).+1 =
(size (rm_rep (ccut c1) [seq ccut i | i <- cs]) +
 size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 =
size
  (if ccut c == ccut c1
   then rm_rep (ccut c1) [seq ccut i | i <- cs]
   else
    ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
    apply/eqP => /val_eqP.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
i:ordinal_finType (n - t)
val d == val (tuc_ord i) -> False
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
(size cs).+1 =
(size (rm_rep (ccut c1) [seq ccut i | i <- cs]) +
 size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 =
size
  (if ccut c == ccut c1
   then rm_rep (ccut c1) [seq ccut i | i <- cs]
   else
    ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
    by rewrite /= eqn_leq [_ <= d]leqNgt (leq_trans dLt) ?andbF // leq_addl.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
(size cs).+1 =
(size (rm_rep (ccut c1) [seq ccut i | i <- cs]) +
 size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 =
size
  (if ccut c == ccut c1
   then rm_rep (ccut c1) [seq ccut i | i <- cs]
   else
    ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
  by congr (_.+1); apply: IH.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 =
size
  (if ccut c == ccut c1
   then rm_rep (ccut c1) [seq ccut i | i <- cs]
   else
    ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
rewrite ifT; last first.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
ccut c == ccut c1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 =
size (rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
  apply/eqP/ffunP=> i; rewrite !ffunE dH2 //.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
i:ordinal_finType t
d != widen_ord tLn i
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 =
size (rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
  by apply/eqP => /val_eqP; rewrite /= eqn_leq leqNgt (leq_trans (ltn_ord _)).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 =
size (rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size
  (if ctuc c == ctuc c1
   then rm_rep (ctuc c1) [seq ctuc i | i <- cs]
   else
    ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
rewrite ifN /= ?addSn; last first.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
ctuc c != ctuc c1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 =
size (rm_rep (ccut c1) [seq ccut i | i <- cs]) +
(size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
  apply/eqP => /ffunP /(_ (otuc tLd)) /eqP.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
ctuc c (otuc tLd) == ctuc c1 (otuc tLd) -> False
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 =
size (rm_rep (ccut c1) [seq ccut i | i <- cs]) +
(size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
  by rewrite !ffunE otucK (negPf cdDc1d).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
path (move rel) c cs ->
size cs =
size (rm_rep (ccut c) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 =
size (rm_rep (ccut c1) [seq ccut i | i <- cs]) +
(size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
by rewrite addnS; congr (_.+1); apply: IH.
Qed.

Lemma gdist_cut_tuc c1 c2 cs : 
    last c1 cs = c2 -> path (move rel) c1 cs ->
   `d[ccut c1, ccut c2]_(move rel) + `d[ctuc c1, ctuc c2]_(move rel) <= size cs.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
last c1 cs = c2 ->
path (move rel) c1 cs ->
`d[ccut c1, ccut c2]_(move rel) +
`d[ctuc c1, ctuc c2]_(move rel) <= size cs
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
last c1 cs = c2 ->
path (move rel) c1 cs ->
`d[ccut c1, ccut c2]_(move rel) +
`d[ctuc c1, ctuc c2]_(move rel) <= size cs
move=> cL cPcs.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
`d[ccut c1, ccut c2]_(move rel) +
`d[ctuc c1, ctuc c2]_(move rel) <= size cs
rewrite (@size_cut_tuc c1) //.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
`d[ccut c1, ccut c2]_(move rel) +
`d[ctuc c1, ctuc c2]_(move rel) <=
size (rm_rep (ccut c1) [seq ccut i | i <- cs]) +
size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])
apply: leq_add.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
`d[ccut c1, ccut c2]_(move rel) <=
size (rm_rep (ccut c1) [seq ccut i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
`d[ctuc c1, ctuc c2]_(move rel) <=
size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])
  apply: gdist_path_le; first by apply: path_cut.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
last (ccut c1)
  (rm_rep (ccut c1) [seq ccut i | i <- cs]) = ccut c2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
`d[ctuc c1, ctuc c2]_(move rel) <=
size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])
  by rewrite last_rm_rep last_map cL.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
`d[ctuc c1, ctuc c2]_(move rel) <=
size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])
apply: gdist_path_le; first by apply: path_tuc.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
last (ctuc c1)
  (rm_rep (ctuc c1) [seq ctuc i | i <- cs]) = ctuc c2
by rewrite last_rm_rep last_map cL.
Qed.

Lemma gpath_cut_tuc c1 c2 cs : 
    gpath (move rel) c1 c2 cs ->
   `d[ccut c1, ccut c2]_(move rel) + `d[ctuc c1, ctuc c2]_(move rel)
      <= `d[c1,c2]_(move rel).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gpath (move rel) c1 c2 cs ->
`d[ccut c1, ccut c2]_(move rel) +
`d[ctuc c1, ctuc c2]_(move rel) <=
`d[c1, c2]_(move rel)
Proof.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gpath (move rel) c1 c2 cs ->
`d[ccut c1, ccut c2]_(move rel) +
`d[ctuc c1, ctuc c2]_(move rel) <=
`d[c1, c2]_(move rel)
move=> gH.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs
`d[ccut c1, ccut c2]_(move rel) +
`d[ctuc c1, ctuc c2]_(move rel) <=
`d[c1, c2]_(move rel)
rewrite (gpath_dist gH).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs
`d[ccut c1, ccut c2]_(move rel) +
`d[ctuc c1, ctuc c2]_(move rel) <= size cs
apply: gdist_cut_tuc => //; first apply: gpath_last gH.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq
  (finfun_finType (ordinal_finType n)
     (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs
path (move rel) c1 cs
by apply: gpath_path gH. 
Qed.

End CSet.


Section ISet.


(* Number of disks *)
Variable n : nat.
(* Subset of disks *)
Variable sd : {set disk n}.
(* Number of pegs *)
Variable k : nat.
(* Subset of pegs *)
Variable sp : {set peg k}.
(* The subset is non empty *)
Variable p0 : peg k.
Variable p0Isp : p0 \in sp.

(* relations on peg *)
Variable rel1 : rel (peg k). 
Variable rel2 : rel (peg #|sp|). 
Hypothesis rel_compat : 
  forall p1 p2, p1 \in sp -> p2 \in sp ->
    rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2).

(* Valid conf : disk in sd are on pegs in sp *)
Definition cvalid (c : configuration k n) :=
  [forall i, (i \in sd) ==> (c i \in sp)].

Lemma cvalidP (c : configuration k n) :
  reflect (forall i, i \in sd -> c i \in sp)
          (cvalid c).
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
reflect
  (forall i : ordinal_finType n,
   i \in sd -> c i \in sp) (cvalid c)
Proof.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
reflect
  (forall i : ordinal_finType n,
   i \in sd -> c i \in sp) (cvalid c)
apply: (iffP forallP) => [H d|H d]; first by have /implyP := H d.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
H:forall i : ordinal_finType n,
i \in sd -> c i \in sp
d:ordinal_finType n
(d \in sd) ==> (c d \in sp)
by apply/implyP/H.
Qed.


Definition cset2 (c : configuration k n) : configuration #|sp| #|sd| := 
  [ffun i => enum_rank_in p0Isp (c (enum_val i))].

Lemma on_top_cset2 c d (dIsd : d \in sd) : 
  cvalid c -> on_top d c -> on_top (enum_rank_in dIsd d) (cset2 c).
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cvalid c ->
on_top d c -> on_top (enum_rank_in dIsd d) (cset2 c)
Proof.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cvalid c ->
on_top d c -> on_top (enum_rank_in dIsd d) (cset2 c)
move=> /= /cvalidP cV /on_topP dO.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n,
i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
on_top (enum_rank_in dIsd d) (cset2 c)
apply/on_topP => /= d1 H.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n,
i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
enum_rank_in dIsd d <= d1
rewrite leq_eqVlt; case: eqP => //= /eqP dDd1.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n,
i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1
enum_rank_in dIsd d < d1
rewrite -[d1](enum_valK_in dIsd) -sorted_enum_val !enum_rankK_in //; last first.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n,
i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1
enum_val d1 \in sd
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n,
i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1
d < enum_val d1
  by apply: enum_valP.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n,
i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1
d < enum_val d1
rewrite ltn_neqAle.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n,
i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1
(d != enum_val d1) && (d <= enum_val d1)
case: eqP => [/eqP /val_eqP dEd1 | /eqP dDd1' /=].
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n,
i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1
dEd1:d = enum_val d1
~~ true && (d <= enum_val d1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n,
i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
d <= enum_val d1
  by case/eqP: dDd1; rewrite {2}dEd1 enum_valK_in.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n,
i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
d <= enum_val d1
rewrite !ffunE enum_rankK_in // in H.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n,
i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n,
c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
H:enum_rank_in p0Isp (c d) =
enum_rank_in p0Isp (c (enum_val d1))
d <= enum_val d1
apply: dO.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n,
i \in sd -> c i \in sp
d1:'I_#|[eta sd]|
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
H:enum_rank_in p0Isp (c d) =
enum_rank_in p0Isp (c (enum_val d1))
c d = c (enum_val d1)
apply: (@enum_rank_in_inj _ _ _ _ p0Isp p0Isp) => //.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n,
i \in sd -> c i \in sp
d1:'I_#|[eta sd]|
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
H:enum_rank_in p0Isp (c d) =
enum_rank_in p0Isp (c (enum_val d1))
c d \in sp
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n,
i \in sd -> c i \in sp
d1:'I_#|[eta sd]|
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
H:enum_rank_in p0Isp (c d) =
enum_rank_in p0Isp (c (enum_val d1))
c (enum_val d1) \in sp
  by apply: cV.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n,
i \in sd -> c i \in sp
d1:'I_#|[eta sd]|
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
H:enum_rank_in p0Isp (c d) =
enum_rank_in p0Isp (c (enum_val d1))
c (enum_val d1) \in sp
by apply/cV/enum_valP.
Qed.

Lemma move_cset2 (c1 c2 : configuration k n) : 
  all cvalid [::c1; c2] ->
  move rel1 c1 c2 -> (cset2 c1) != (cset2 c2) ->
  move rel2 (cset2 c1) (cset2 c2).
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
all cvalid [:: c1; c2] ->
move rel1 c1 c2 ->
cset2 c1 != cset2 c2 ->
move rel2 (cset2 c1) (cset2 c2)
Proof.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
all cvalid [:: c1; c2] ->
move rel1 c1 c2 ->
cset2 c1 != cset2 c2 ->
move rel2 (cset2 c1) (cset2 c2)
rewrite /=.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
[&& cvalid c1, cvalid c2 & true] ->
move rel1 c1 c2 ->
cset2 c1 != cset2 c2 ->
move rel2 (cset2 c1) (cset2 c2)
move=> /= /and3P[c1V c2V _]  /moveP [d [dH1 dH2 dH3 dH4]] c1Dc2.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
move rel2 (cset2 c1) (cset2 c2)
have [dIsd|dNIsd] := boolP (d \in sd); last first.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dNIsd:d \notin sd
move rel2 (cset2 c1) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
move rel2 (cset2 c1) (cset2 c2)
  case/eqP: c1Dc2.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd
cset2 c1 = cset2 c2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
move rel2 (cset2 c1) (cset2 c2)
  apply/ffunP => i; rewrite !ffunE.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd
i:ordinal_finType #|sd|
enum_rank_in p0Isp (c1 (enum_val i)) =
enum_rank_in p0Isp (c2 (enum_val i))
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
move rel2 (cset2 c1) (cset2 c2)
  apply: enum_val_inj.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd
i:ordinal_finType #|sd|
enum_val (enum_rank_in p0Isp (c1 (enum_val i))) =
enum_val (enum_rank_in p0Isp (c2 (enum_val i)))
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
move rel2 (cset2 c1) (cset2 c2)
  rewrite !enum_rankK_in ?(cvalidP _ c1V) ?(cvalidP _ c2V) ?enum_valP //.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd
i:ordinal_finType #|sd|
c1 (enum_val i) = c2 (enum_val i)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
move rel2 (cset2 c1) (cset2 c2)
  apply: dH2.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd
i:ordinal_finType #|sd|
d != enum_val i
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
move rel2 (cset2 c1) (cset2 c2)
  apply: contra dNIsd => /eqP->.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
i:ordinal_finType #|sd|
enum_val i \in sd
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
move rel2 (cset2 c1) (cset2 c2)
  by apply: enum_valP.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
move rel2 (cset2 c1) (cset2 c2)
apply/moveP; exists (enum_rank_in dIsd d); split => /=.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
rel2 (cset2 c1 (enum_rank_in dIsd d))
  (cset2 c2 (enum_rank_in dIsd d))
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
forall d2 : 'I_#|sd|,
enum_rank_in dIsd d != d2 -> cset2 c1 d2 = cset2 c2 d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
-
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
rel2 (cset2 c1 (enum_rank_in dIsd d))
  (cset2 c2 (enum_rank_in dIsd d))
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
forall d2 : 'I_#|sd|,
enum_rank_in dIsd d != d2 -> cset2 c1 d2 = cset2 c2 d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2) rewrite !ffunE !enum_rankK_in //.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
rel2 (enum_rank_in p0Isp (c1 d))
  (enum_rank_in p0Isp (c2 d))
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
forall d2 : 'I_#|sd|,
enum_rank_in dIsd d != d2 -> cset2 c1 d2 = cset2 c2 d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
  by apply: rel_compat=> //; [apply: (cvalidP _ c1V) | 
                              apply: (cvalidP _ c2V)].
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
forall d2 : 'I_#|sd|,
enum_rank_in dIsd d != d2 -> cset2 c1 d2 = cset2 c2 d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
-
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
forall d2 : 'I_#|sd|,
enum_rank_in dIsd d != d2 -> cset2 c1 d2 = cset2 c2 d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2) move=> /= d2 dDd2.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2
cset2 c1 d2 = cset2 c2 d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
  rewrite !ffunE.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2
enum_rank_in p0Isp (c1 (enum_val d2)) =
enum_rank_in p0Isp (c2 (enum_val d2))
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
  congr (enum_rank_in _ _).
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2
c1 (enum_val d2) = c2 (enum_val d2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
  apply: dH2.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2
d != enum_val d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
  rewrite -[d](enum_rankK_in dIsd) //.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2
enum_val (enum_rank_in dIsd d) != enum_val d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
  by apply /eqP => /enum_val_inj /eqP; rewrite (negPf dDd2).
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
-
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2) by apply: on_top_cset2.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
by apply: on_top_cset2.
Qed.

Lemma path_cset2 (c : configuration _ _) cs :
    all cvalid (c :: cs) ->
    path (move rel1) c cs ->
    path (move rel2) (cset2 c) (rm_rep (cset2 c) [seq (cset2 i) | i <- cs]).
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
cs:seq (configuration k n)
all cvalid (c :: cs) ->
path (move rel1) c cs ->
path (move rel2) (cset2 c)
  (rm_rep (cset2 c) [seq cset2 i | i <- cs])
Proof.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c:configuration k n
cs:seq (configuration k n)
all cvalid (c :: cs) ->
path (move rel1) c cs ->
path (move rel2) (cset2 c)
  (rm_rep (cset2 c) [seq cset2 i | i <- cs])
elim: cs c => //= c1 cs IH c => /and3P[c1V c2V c3V] /andP[cMc1 c1Pcs].
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid c && all cvalid cs ->
path (move rel1) c cs ->
path (move rel2) (cset2 c)
  (rm_rep (cset2 c) [seq cset2 i | i <- cs])
c:configuration k n
c1V:cvalid c
c2V:cvalid c1
c3V:all cvalid cs
cMc1:move rel1 c c1
c1Pcs:path (move rel1) c1 cs
path (move rel2) (cset2 c)
  (if cset2 c == cset2 c1
   then rm_rep (cset2 c1) [seq cset2 i | i <- cs]
   else
    cset2 c1
    :: rm_rep (cset2 c1) [seq cset2 i | i <- cs])
case: eqP => [->|/eqP cDc1 /=]; first by apply: IH; rewrite ?c2V.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid c && all cvalid cs ->
path (move rel1) c cs ->
path (move rel2) (cset2 c)
  (rm_rep (cset2 c) [seq cset2 i | i <- cs])
c:configuration k n
c1V:cvalid c
c2V:cvalid c1
c3V:all cvalid cs
cMc1:move rel1 c c1
c1Pcs:path (move rel1) c1 cs
cDc1:cset2 c != cset2 c1
move rel2 (cset2 c) (cset2 c1) &&
path (move rel2) (cset2 c1)
  (rm_rep (cset2 c1) [seq cset2 i | i <- cs])
rewrite move_cset2 => //=; first by apply: IH; rewrite ?c2V.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid c && all cvalid cs ->
path (move rel1) c cs ->
path (move rel2) (cset2 c)
  (rm_rep (cset2 c) [seq cset2 i | i <- cs])
c:configuration k n
c1V:cvalid c
c2V:cvalid c1
c3V:all cvalid cs
cMc1:move rel1 c c1
c1Pcs:path (move rel1) c1 cs
cDc1:cset2 c != cset2 c1
[&& cvalid c, cvalid c1 & true]
by rewrite c1V c2V.
Qed.

Lemma gdist_cset2 c1 c2 cs : 
    all cvalid (c1 :: cs) -> last c1 cs = c2 -> path (move rel1) c1 cs ->
   `d[cset2 c1, cset2 c2]_(move rel2) <= size cs.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
cs:seq (configuration k n)
all cvalid (c1 :: cs) ->
last c1 cs = c2 ->
path (move rel1) c1 cs ->
`d[cset2 c1, cset2 c2]_(move rel2) <= size cs
Proof.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
cs:seq (configuration k n)
all cvalid (c1 :: cs) ->
last c1 cs = c2 ->
path (move rel1) c1 cs ->
`d[cset2 c1, cset2 c2]_(move rel2) <= size cs
move=> cV cL cPcs.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
cs:seq (configuration k n)
cV:all cvalid (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs
`d[cset2 c1, cset2 c2]_(move rel2) <= size cs
have := size_rm_rep (cset2 c1) [seq (cset2 i) | i <- cs].
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
cs:seq (configuration k n)
cV:all cvalid (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs
size (rm_rep (cset2 c1) [seq cset2 i | i <- cs]) <=
size [seq cset2 i | i <- cs] ->
`d[cset2 c1, cset2 c2]_(move rel2) <= size cs
rewrite size_map; move/(leq_trans _); apply.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
cs:seq (configuration k n)
cV:all cvalid (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs
`d[cset2 c1, cset2 c2]_(move rel2) <=
size (rm_rep (cset2 c1) [seq cset2 i | i <- cs])
apply: gdist_path_le; first by apply: path_cset2.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1, c2:configuration k n
cs:seq (configuration k n)
cV:all cvalid (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs
last (cset2 c1)
  (rm_rep (cset2 c1) [seq cset2 i | i <- cs]) =
cset2 c2
by rewrite last_rm_rep last_map cL.
Qed.

Lemma gpath_cset2 c1 c2 cs : 
    all cvalid (c1 :: cs) -> gpath (move rel1) c1 c2 cs ->
   `d[cset2 c1, cset2 c2]_(move rel2) <= `d[c1, c2]_(move rel1).
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1:configuration k n
c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq (configuration k n)
all cvalid (c1 :: cs) ->
gpath (move rel1) c1 c2 cs ->
`d[cset2 c1, cset2 c2]_(move rel2) <=
`d[c1, c2]_(move rel1)
Proof.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1:configuration k n
c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq (configuration k n)
all cvalid (c1 :: cs) ->
gpath (move rel1) c1 c2 cs ->
`d[cset2 c1, cset2 c2]_(move rel2) <=
`d[c1, c2]_(move rel1)
move=> cV gH.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1:configuration k n
c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq (configuration k n)
cV:all cvalid (c1 :: cs)
gH:gpath (move rel1) c1 c2 cs
`d[cset2 c1, cset2 c2]_(move rel2) <=
`d[c1, c2]_(move rel1)
rewrite (gpath_dist gH); apply: gdist_cset2 => //; first apply: gpath_last gH.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k,
p1 \in sp ->
p2 \in sp ->
rel1 p1 p2 ->
rel2 (enum_rank_in p0Isp p1)
  (enum_rank_in p0Isp p2)
c1:configuration k n
c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq (configuration k n)
cV:all cvalid (c1 :: cs)
gH:gpath (move rel1) c1 c2 cs
path (move rel1) c1 cs
by apply: gpath_path gH.
Qed.

End ISet.


Section ISet2.

(* Number of disks *)
Variable n : nat.
(* Subset of disks *)
Variable sd : {set disk n}.
(* Number of pegs *)
Variable k : nat.
(* Subsets of pegs *)
Variables sp1 sp2 : {set peg k}.
(* The subsets are non empty *)
Variable p1 p2 : peg k.
Variable p1Isp1 : p1 \in sp1.
Variable p2Isp2 : p2 \in sp2.

(* relations on peg *)
Variable rel1 : rel (peg k). 
Variable rel2 : rel (peg #|sp1|). 
Variable rel3 : rel (peg #|sp2|). 
Hypothesis irH : irreflexive rel1.
Hypothesis rel2_compat : 
  forall pi pj, pi \in sp1 -> pj \in sp1 ->
    rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj).
Hypothesis rel3_compat : 
  forall pi pj, pi \in sp2 -> pj \in sp2 ->
    rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj).

Lemma size_cset2 (c : configuration _ _) cs :
    all (cvalid sd sp1) (c :: cs) ->
    all (cvalid (~: sd) sp2) (c :: cs) ->
    path (move rel1) c cs ->
    size cs = 
     (size (rm_rep (cset2 sd p1Isp1 c) [seq (cset2 sd  p1Isp1 i) | i <- cs]) +
      size (rm_rep (cset2 (~: sd) p2Isp2 c)
             [seq (cset2 (~: sd) p2Isp2 i) | i <- cs]))%nat.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c:configuration k n
cs:seq (configuration k n)
all (cvalid sd sp1) (c :: cs) ->
all (cvalid (~: sd) sp2) (c :: cs) ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
Proof.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c:configuration k n
cs:seq (configuration k n)
all (cvalid sd sp1) (c :: cs) ->
all (cvalid (~: sd) sp2) (c :: cs) ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
elim: cs c => //= c1 cs IH c /and3P[c1V1 c2V1 c3V1] 
                             /and3P[c1V2 c2V2 c3V2] 
                             /andP[/moveP[d [dH1 dH2 dH3 dH4]] c1Pcs].
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
(size cs).+1 =
size
  (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
   then
    rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]
   else
    cset2 sd p1Isp1 c1
    :: rm_rep (cset2 sd p1Isp1 c1)
         [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
have cdDc1d : c d != c1 d.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
c d != c1 d
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
(size cs).+1 =
size
  (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
   then
    rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]
   else
    cset2 sd p1Isp1 c1
    :: rm_rep (cset2 sd p1Isp1 c1)
         [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
  by have /idP/negP := irH (c d); apply: contra => /eqP {2}->.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
(size cs).+1 =
size
  (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
   then
    rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]
   else
    cset2 sd p1Isp1 c1
    :: rm_rep (cset2 sd p1Isp1 c1)
         [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
have [dIsd|dNIsd] := boolP (d \in sd).
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 =
size
  (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
   then
    rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]
   else
    cset2 sd p1Isp1 c1
    :: rm_rep (cset2 sd p1Isp1 c1)
         [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 =
size
  (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
   then
    rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]
   else
    cset2 sd p1Isp1 c1
    :: rm_rep (cset2 sd p1Isp1 c1)
         [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
  rewrite ifN /= ?addSn; last first.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
cset2 sd p1Isp1 c != cset2 sd p1Isp1 c1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 =
(size
   (rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]) +
 size
   (if
     cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
    then
     rm_rep (cset2 (~: sd) p2Isp2 c1)
       [seq cset2 (~: sd) p2Isp2 i | i <- cs]
    else
     cset2 (~: sd) p2Isp2 c1
     :: rm_rep (cset2 (~: sd) p2Isp2 c1)
          [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 =
size
  (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
   then
    rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]
   else
    cset2 sd p1Isp1 c1
    :: rm_rep (cset2 sd p1Isp1 c1)
         [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
    apply/eqP => /ffunP /(_ (enum_rank_in dIsd d)).
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
cset2 sd p1Isp1 c (enum_rank_in dIsd d) =
cset2 sd p1Isp1 c1 (enum_rank_in dIsd d) -> False
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 =
(size
   (rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]) +
 size
   (if
     cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
    then
     rm_rep (cset2 (~: sd) p2Isp2 c1)
       [seq cset2 (~: sd) p2Isp2 i | i <- cs]
    else
     cset2 (~: sd) p2Isp2 c1
     :: rm_rep (cset2 (~: sd) p2Isp2 c1)
          [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 =
size
  (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
   then
    rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]
   else
    cset2 sd p1Isp1 c1
    :: rm_rep (cset2 sd p1Isp1 c1)
         [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
    rewrite !ffunE enum_rankK_in // => /enum_rank_in_inj => H.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
H:c d \in sp1 -> c1 d \in sp1 -> c d = c1 d
False
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 =
(size
   (rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]) +
 size
   (if
     cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
    then
     rm_rep (cset2 (~: sd) p2Isp2 c1)
       [seq cset2 (~: sd) p2Isp2 i | i <- cs]
    else
     cset2 (~: sd) p2Isp2 c1
     :: rm_rep (cset2 (~: sd) p2Isp2 c1)
          [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 =
size
  (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
   then
    rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]
   else
    cset2 sd p1Isp1 c1
    :: rm_rep (cset2 sd p1Isp1 c1)
         [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
    case/eqP : cdDc1d; apply: H; first by have /cvalidP := c1V1; apply.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
dIsd:d \in sd
c1 d \in sp1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 =
(size
   (rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]) +
 size
   (if
     cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
    then
     rm_rep (cset2 (~: sd) p2Isp2 c1)
       [seq cset2 (~: sd) p2Isp2 i | i <- cs]
    else
     cset2 (~: sd) p2Isp2 c1
     :: rm_rep (cset2 (~: sd) p2Isp2 c1)
          [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 =
size
  (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
   then
    rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]
   else
    cset2 sd p1Isp1 c1
    :: rm_rep (cset2 sd p1Isp1 c1)
         [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
    by have /cvalidP := c2V1; apply.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 =
(size
   (rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]) +
 size
   (if
     cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
    then
     rm_rep (cset2 (~: sd) p2Isp2 c1)
       [seq cset2 (~: sd) p2Isp2 i | i <- cs]
    else
     cset2 (~: sd) p2Isp2 c1
     :: rm_rep (cset2 (~: sd) p2Isp2 c1)
          [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 =
size
  (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
   then
    rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]
   else
    cset2 sd p1Isp1 c1
    :: rm_rep (cset2 sd p1Isp1 c1)
         [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
  rewrite ifT; last first.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 =
(size
   (rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]) +
 size
   (rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 =
size
  (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
   then
    rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]
   else
    cset2 sd p1Isp1 c1
    :: rm_rep (cset2 sd p1Isp1 c1)
         [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
    apply/eqP/ffunP=> i; rewrite !ffunE dH2 //.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
i:ordinal_finType #|~: sd|
d != enum_val i
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 =
(size
   (rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]) +
 size
   (rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 =
size
  (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
   then
    rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]
   else
    cset2 sd p1Isp1 c1
    :: rm_rep (cset2 sd p1Isp1 c1)
         [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
    have := enum_valP i; rewrite inE.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
i:ordinal_finType #|~: sd|
enum_val i \notin sd -> d != enum_val i
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 =
(size
   (rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]) +
 size
   (rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 =
size
  (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
   then
    rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]
   else
    cset2 sd p1Isp1 c1
    :: rm_rep (cset2 sd p1Isp1 c1)
         [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
    by apply: contra => /eqP<-.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 =
(size
   (rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]) +
 size
   (rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 =
size
  (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
   then
    rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]
   else
    cset2 sd p1Isp1 c1
    :: rm_rep (cset2 sd p1Isp1 c1)
         [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
  by congr (_.+1); apply: IH; rewrite ?c2V1 ?c2V2.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 =
size
  (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
   then
    rm_rep (cset2 sd p1Isp1 c1)
      [seq cset2 sd p1Isp1 i | i <- cs]
   else
    cset2 sd p1Isp1 c1
    :: rm_rep (cset2 sd p1Isp1 c1)
         [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
rewrite ifT; last first.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 =
size
  (rm_rep (cset2 sd p1Isp1 c1)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
  apply/eqP/ffunP=> i; rewrite !ffunE dH2 //.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
i:ordinal_finType #|sd|
d != enum_val i
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 =
size
  (rm_rep (cset2 sd p1Isp1 c1)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
  apply: contra dNIsd => /eqP->.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
i:ordinal_finType #|sd|
enum_val i \in sd
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 =
size
  (rm_rep (cset2 sd p1Isp1 c1)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
  by have := enum_valP i.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 =
size
  (rm_rep (cset2 sd p1Isp1 c1)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
have dd : d \in ~: sd by rewrite inE.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
(size cs).+1 =
size
  (rm_rep (cset2 sd p1Isp1 c1)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (if
    cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
   then
    rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs]
   else
    cset2 (~: sd) p2Isp2 c1
    :: rm_rep (cset2 (~: sd) p2Isp2 c1)
         [seq cset2 (~: sd) p2Isp2 i | i <- cs])
rewrite ifN /= ?addSn; last first.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
cset2 (~: sd) p2Isp2 c != cset2 (~: sd) p2Isp2 c1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
(size cs).+1 =
size
  (rm_rep (cset2 sd p1Isp1 c1)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
(size
   (rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
  apply/eqP => /ffunP /(_ (enum_rank_in dd d)).
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
cset2 (~: sd) p2Isp2 c (enum_rank_in dd d) =
cset2 (~: sd) p2Isp2 c1 (enum_rank_in dd d) -> False
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
(size cs).+1 =
size
  (rm_rep (cset2 sd p1Isp1 c1)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
(size
   (rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
  rewrite !ffunE enum_rankK_in // => /enum_rank_in_inj => H.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
H:c d \in sp2 -> c1 d \in sp2 -> c d = c1 d
False
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
(size cs).+1 =
size
  (rm_rep (cset2 sd p1Isp1 c1)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
(size
   (rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
  case/eqP : cdDc1d; apply: H.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
dNIsd:d \notin sd
dd:d \in ~: sd
c d \in sp2
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
dNIsd:d \notin sd
dd:d \in ~: sd
c1 d \in sp2
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
(size cs).+1 =
size
  (rm_rep (cset2 sd p1Isp1 c1)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
(size
   (rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
    by have /cvalidP := c1V2; apply.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
dNIsd:d \notin sd
dd:d \in ~: sd
c1 d \in sp2
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
(size cs).+1 =
size
  (rm_rep (cset2 sd p1Isp1 c1)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
(size
   (rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
  by have /cvalidP := c2V2; apply.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n,
cvalid sd sp1 c && all (cvalid sd sp1) cs ->
cvalid (~: sd) sp2 c &&
all (cvalid (~: sd) sp2) cs ->
path (move rel1) c cs ->
size cs =
size
  (rm_rep (cset2 sd p1Isp1 c)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n,
d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
(size cs).+1 =
size
  (rm_rep (cset2 sd p1Isp1 c1)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
(size
   (rm_rep (cset2 (~: sd) p2Isp2 c1)
      [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
by rewrite addnS; congr (_.+1); apply: IH; rewrite ?c2V1 ?c2V2.
Qed.

Lemma gdist_cset22 c1 c2 cs : 
    all (cvalid sd sp1) (c1 :: cs) -> all (cvalid (~: sd) sp2) (c1 :: cs) ->
    last c1 cs = c2 -> path (move rel1) c1 cs ->
   `d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) +
   `d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2  c2]_(move rel3)
      <= size cs.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
all (cvalid sd sp1) (c1 :: cs) ->
all (cvalid (~: sd) sp2) (c1 :: cs) ->
last c1 cs = c2 ->
path (move rel1) c1 cs ->
`d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) +
`d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_
(move rel3) <= size cs
Proof.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
all (cvalid sd sp1) (c1 :: cs) ->
all (cvalid (~: sd) sp2) (c1 :: cs) ->
last c1 cs = c2 ->
path (move rel1) c1 cs ->
`d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) +
`d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_
(move rel3) <= size cs
move=> cV1 cV2 cL cPcs.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs
`d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) +
`d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_
(move rel3) <= size cs
rewrite (size_cset2 cV1 cV2) //.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs
`d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) +
`d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_
(move rel3) <=
size
  (rm_rep (cset2 sd p1Isp1 c1)
     [seq cset2 sd p1Isp1 i | i <- cs]) +
size
  (rm_rep (cset2 (~: sd) p2Isp2 c1)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
apply: leq_add.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs
`d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) <=
size
  (rm_rep (cset2 sd p1Isp1 c1)
     [seq cset2 sd p1Isp1 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs
`d[cset2 (~: sd) p2Isp2 c1, 
cset2 (~: sd) p2Isp2 c2]_
(move rel3) <=
size
  (rm_rep (cset2 (~: sd) p2Isp2 c1)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
  apply: gdist_path_le; first by apply: path_cset2 rel2_compat _ _ _ _.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs
last (cset2 sd p1Isp1 c1)
  (rm_rep (cset2 sd p1Isp1 c1)
     [seq cset2 sd p1Isp1 i | i <- cs]) =
cset2 sd p1Isp1 c2
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs
`d[cset2 (~: sd) p2Isp2 c1, 
cset2 (~: sd) p2Isp2 c2]_
(move rel3) <=
size
  (rm_rep (cset2 (~: sd) p2Isp2 c1)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
  by rewrite last_rm_rep last_map cL.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs
`d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_
(move rel3) <=
size
  (rm_rep (cset2 (~: sd) p2Isp2 c1)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs])
apply: gdist_path_le; first by apply: path_cset2 rel3_compat _ _ _ _.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs
last (cset2 (~: sd) p2Isp2 c1)
  (rm_rep (cset2 (~: sd) p2Isp2 c1)
     [seq cset2 (~: sd) p2Isp2 i | i <- cs]) =
cset2 (~: sd) p2Isp2 c2
by rewrite last_rm_rep last_map cL.
Qed.

Lemma gpath_cset22 c1 c2 cs : 
    all (cvalid sd sp1) (c1 :: cs) -> all (cvalid (~: sd) sp2) (c1 :: cs) ->
    gpath (move rel1) c1 c2 cs ->
   `d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) +
   `d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2  c2]_(move rel3)
      <= `d[c1,c2]_(move rel1).
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq (configuration k n)
all (cvalid sd sp1) (c1 :: cs) ->
all (cvalid (~: sd) sp2) (c1 :: cs) ->
gpath (move rel1) c1 c2 cs ->
`d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) +
`d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_
(move rel3) <= `d[c1, c2]_(move rel1)
Proof.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq (configuration k n)
all (cvalid sd sp1) (c1 :: cs) ->
all (cvalid (~: sd) sp2) (c1 :: cs) ->
gpath (move rel1) c1 c2 cs ->
`d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) +
`d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_
(move rel3) <= `d[c1, c2]_(move rel1)
move=> cV1 cV2 gH.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
gH:gpath (move rel1) c1 c2 cs
`d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) +
`d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_
(move rel3) <= `d[c1, c2]_(move rel1)
rewrite (gpath_dist gH).
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
gH:gpath (move rel1) c1 c2 cs
`d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) +
`d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_
(move rel3) <= size cs
apply: gdist_cset22 => //; first apply: gpath_last gH.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k,
pi \in sp1 ->
pj \in sp1 ->
rel1 pi pj ->
rel2 (enum_rank_in p1Isp1 pi)
  (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k,
pi \in sp2 ->
pj \in sp2 ->
rel1 pi pj ->
rel3 (enum_rank_in p2Isp2 pi)
  (enum_rank_in p2Isp2 pj)
c1:configuration k n
c2:finfun_finType (ordinal_finType n)
  (ordinal_finType k)
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
gH:gpath (move rel1) c1 c2 cs
path (move rel1) c1 cs
by apply: gpath_path gH. 
Qed.

End ISet2.